.gitignore 0000664 0000000 0000000 00000000140 15167050144 0013044 0 ustar 00root root 0000000 0000000 /build
/node_modules
/*.log
/yarn.lock
/package-lock.json
.idea/workspace.xml
.idea/tasks.xml
.idea/ 0000775 0000000 0000000 00000000000 15167050144 0012041 5 ustar 00root root 0000000 0000000 .idea/corifeus-utils.iml 0000664 0000000 0000000 00000000520 15167050144 0015516 0 ustar 00root root 0000000 0000000
.idea/misc.xml 0000664 0000000 0000000 00000000256 15167050144 0013521 0 ustar 00root root 0000000 0000000
.idea/modules.xml 0000664 0000000 0000000 00000000430 15167050144 0014230 0 ustar 00root root 0000000 0000000
.idea/vcs.xml 0000664 0000000 0000000 00000000247 15167050144 0013361 0 ustar 00root root 0000000 0000000
.npmignore 0000664 0000000 0000000 00000000222 15167050144 0013054 0 ustar 00root root 0000000 0000000 /.idea
/artifacts
/build
/test
/node_modules
/*.iml
/*.ipr
/*.iws
/.travis.yml
/.scrutinizer.yml
/Gruntfile.js
/*.lock
*.log
/corifeus-boot.json
.scrutinizer.yml 0000664 0000000 0000000 00000000547 15167050144 0014251 0 ustar 00root root 0000000 0000000 checks:
javascript: true
filter:
excluded_paths:
- test/*
- node_modules/*
- build/*
- docs/*
build:
environment:
node: 7.8
dependencies:
before:
- npm install -g grunt-cli
tests:
override:
-
command: 'grunt'
coverage:
file: 'build/coverage/clover.xml'
format: 'clover'
.travis.yml 0000664 0000000 0000000 00000000133 15167050144 0013167 0 ustar 00root root 0000000 0000000 language: node_js
node_js:
- "7"
- "node"
before_script:
- npm install grunt-cli -g
Gruntfile.js 0000664 0000000 0000000 00000000420 15167050144 0013352 0 ustar 00root root 0000000 0000000 module.exports = (grunt) => {
const builder = require(`corifeus-builder`);
const loader = new builder.loader(grunt);
loader.js({
replacer: {
npmio: true
}
});
grunt.registerTask('default', builder.config.task.build.js);
}
LICENSE 0000664 0000000 0000000 00000002140 15167050144 0012063 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2017 Patrik Laszlo / patrikx3 / https://patrikx3.tk and contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
README.md 0000664 0000000 0000000 00000006557 15167050144 0012355 0 ustar 00root root 0000000 0000000 [//]: #@corifeus-header
[](https://travis-ci.org/patrikx3/corifeus-utils) [](https://scrutinizer-ci.com/g/patrikx3/corifeus-utils/?branch=master) [](https://scrutinizer-ci.com/g/patrikx3/corifeus-utils/?branch=master)
[](https://www.npmjs.com/package/corifeus-utils/)
---
# Corifeus Utils - Memory
## Issues / Support
This is an open source project. Time is a precious thing, so I have rarely time to give support and fix issues for someone else. I fix a bug, when I have an error that I need. If you got an issue, error or bug, I hope someone will have time to do it for you, otherwise, you are on your own.
Though, if I know the solution, I will tell you. Besides, core errors will be fixed by me.
***If you want to extend, fix bugs or add in new features, I promptly merge pull requests or you can become a ```patrikx3``` member.***
Besides, when I can support, please note, I cannot support old versions, only the current/latest version.
### Node Version Requirement
```
>=7.8.0
```
### Built on Node
```
v8.1.0
```
The ```async``` and ```await``` keywords are required.
Install NodeJs:
https://nodejs.org/en/download/package-manager/
### Updating
Since, I work full time, I can work only on weekends. Github updates are released only Sundays. Minor errors can be released any time, but reflects will be shown only in NPM.
# Description
[//]: #@corifeus-header:end
Misc utils (async array iterator, random characters, exit on silent ```unhandledRejection``` errors, etc...)
```javascript
const utils = require('corifeus-utils');
```
* Modules
* Async Array Iterator ```forEachAsync```
* ```JSON.strintify``` for ```Error```
* Lodash Pascal
* Remove silent process ```unhandledRejection``` end ```process.exit()```, adds timestamp
* Process ```uncaughtException``` that shows timestamp.
* Random async Base62 string
* Replace inject - finds a prefix and postfix in a string and replace the content, ```strings.inject```
* Convert a byte array or string to base62, ```utils.base.charset(string)```
* Async Hash (SHA-512, SHA-256) file using Base62,
* Promise based HTTP Request
* Time utilies
* Additional file system utils
* JSON based file database
* HTTP/HTTPS based async/Promise request
# Actual modules
* time
* verbose
* span
* regexp
* escape
* random
* async (default is base62)
* promise
* deferred (simple extract the reject, resolve and promise function, instead of callback)
* process
* unhandledRejection
* uncaughtException
* writableCallbackExit
* object
* reduce
* hash
* async file
* string
* padStart
* empty
* inject
* lodash
* PascalCase
* http
* async request
* db
* file based json storage
* child-process
* async exec
* array
* forEachAsync, async for each
[//]: #@corifeus-footer
---
[**CORIFEUS-UTILS**](https://pages.corifeus.tk/corifeus-utils) Build v1.1.328-18
[Corifeus](http://www.corifeus.tk) by [Patrik Laszlo](http://patrikx3.tk)
[//]: #@corifeus-footer:end
corifeus-utils.iml 0000664 0000000 0000000 00000000760 15167050144 0014544 0 ustar 00root root 0000000 0000000
package.json 0000664 0000000 0000000 00000002273 15167050144 0013353 0 ustar 00root root 0000000 0000000 {
"name": "corifeus-utils",
"version": "1.1.328-18",
"corifeus": {
"icon": "fa fa-lightbulb-o",
"code": "Memory",
"publish": true
},
"description": "Corifeus Utils - Memory",
"main": "src/index.js",
"directories": {
"test": "test"
},
"scripts": {
"test": "grunt",
"coverage": "istanbul cover node_modules/mocha/bin/_mocha --report clover -- -R spec test/mocha/**/*.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/patrikx3/corifeus-utils.git"
},
"keywords": [
"corifeus",
"nodejs",
"node",
"utils"
],
"author": "Patrik Laszlo ",
"license": "MIT",
"bugs": {
"url": "https://github.com/patrikx3/corifeus-utils/issues"
},
"homepage": "https://pages.corifeus.tk/corifeus-utils",
"devDependencies": {
"corifeus-builder": "^1.7.660-16"
},
"dependencies": {
"fs-extra": "^3.0.1",
"glob": "^7.1.2",
"lodash": "^4.17.4",
"ms": "^2.0.0",
"mz": "^2.6.0",
"timestring": "^4.0.0"
},
"engines": {
"node": ">=7.8.0"
}
} src/ 0000775 0000000 0000000 00000000000 15167050144 0011650 5 ustar 00root root 0000000 0000000 src/array/ 0000775 0000000 0000000 00000000000 15167050144 0012766 5 ustar 00root root 0000000 0000000 src/array/for-each-async.js 0000664 0000000 0000000 00000001334 15167050144 0016124 0 ustar 00root root 0000000 0000000 const forEachAsync = (array, cb, serial = false) => {
const promises = [];
let lastCb;
for(let index = 0; index < array.length; index++) {
const item = array[index];
const call = () => {
cb(item, index)
}
if (serial) {
if (lastCb === undefined) {
lastCb = cb(item, index)
} else {
lastCb = lastCb.then(() => cb(item, index));
}
} else {
promises.push( cb(item, index))
}
}
if (serial) {
return lastCb;
} else {
const result = Promise.all(promises);
result.promises = promises;
return result;
}
}
module.exports = forEachAsync; src/array/index.js 0000664 0000000 0000000 00000000774 15167050144 0014443 0 ustar 00root root 0000000 0000000 module.exports.forEachAsync = require('./for-each-async');
module.exports.isfy = (input) => {
const args = Array.prototype.slice.call(input);
return args.sort();
}
if (!Array.prototype.forEachAsync) {
const forEachAsync = module.exports.forEachAsync;
Object.defineProperty(Array.prototype, 'forEachAsync', {
enumerable: false,
writable: true,
value: function(callback, serial = false) {
return forEachAsync(this, callback, serial);
}
});
}
src/base.js 0000664 0000000 0000000 00000000736 15167050144 0013126 0 ustar 00root root 0000000 0000000 const base62Charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
module.exports.charset = (bytes, charset = base62Charset) => {
let string = ''
for(let index = 0; index < bytes.length; index++) {
const byte = bytes[index];
const percent = (100 / 256 * byte) / 100;
const charIndex = Math.floor(charset.length * percent) ;
const char = charset.charAt(charIndex)
string += char;
}
return string;
}
src/child-process/ 0000775 0000000 0000000 00000000000 15167050144 0014407 5 ustar 00root root 0000000 0000000 src/child-process/index.js 0000664 0000000 0000000 00000001633 15167050144 0016057 0 ustar 00root root 0000000 0000000 const childProcess = require('child_process');
const promiseUtil = require('../promise');
module.exports.exec = (command, options) => {
if (options === true) {
options = {
display: true
}
}
options = options || {};
options.stdio = options.stdio || 'inherit';
options.display = options.display || false;
const { resolve, reject, promise} = promiseUtil.deferred();
const run = childProcess.exec(command, options, (err, stdout, stderr) => {
if (err) {
reject(err);
return;
}
resolve({
stdout: stdout,
stderr: stderr,
})
})
if (options.display === true) {
run.stdout.on('data', (data) => {
console.log(data);
});
run.stderr.on('data', (data) => {
console.error(data);
});
}
promise.exec = run;
return promise
} src/db/ 0000775 0000000 0000000 00000000000 15167050144 0012235 5 ustar 00root root 0000000 0000000 src/db/index.js 0000664 0000000 0000000 00000002644 15167050144 0013710 0 ustar 00root root 0000000 0000000 const coryFs = require('../fs');
const mz = require('mz');
const load = async (dbFile, data = {}) => {
data = await coryFs.ensureFile(dbFile, data)
data = JSON.parse(data.toString());
return new db(dbFile, data);
}
const db = function(dbFile, data) {
const getTime = () => {
return Date.now();
}
if (!data.hasOwnProperty('_createdAt')) {
data._createdAt = getTime();
data._updatedAt = getTime();
}
Object.defineProperty(this, 'raw', {
get: () => {
return data;
}
})
this.exists = function(entity, key) {
if (!data.hasOwnProperty(entity)) {
return false;
}
if (!data[entity].hasOwnProperty(key)) {
return false;
}
return true;
}
this.save = function(entity, key, saveData) {
if (!data.hasOwnProperty(entity)) {
data[entity] = {};
}
if (data[entity].hasOwnProperty(key)) {
saveData._updatedAt = getTime();
data[entity][key] = Object.assign(data[entity][key], saveData);
} else {
saveData._createdAt = getTime();
saveData._updatedAt = getTime();
data[entity][key] = saveData;
}
}
this.write = async function() {
data._updatedAt = getTime();
await mz.fs.writeFile(dbFile, JSON.stringify(data, null, 4));
}
}
module.exports.load = load; src/error.js 0000664 0000000 0000000 00000000571 15167050144 0013342 0 ustar 00root root 0000000 0000000 if (!('toJSON' in Error.prototype)) {
Object.defineProperty(Error.prototype, 'toJSON', {
value: function () {
const alt = {};
Object.getOwnPropertyNames(this).forEach(function (key) {
alt[key] = this[key];
}, this);
return alt;
},
configurable: true,
writable: true
});
}
src/fs/ 0000775 0000000 0000000 00000000000 15167050144 0012260 5 ustar 00root root 0000000 0000000 src/fs/find.js 0000664 0000000 0000000 00000005175 15167050144 0013546 0 ustar 00root root 0000000 0000000 const path = require('path');
const mz = require('mz');
const multi = async (options) => {
await options.find.forEachAsync(async (findable) => {
const resolved = path.resolve(options.root, findable);
const finds = await mz.fs.exists(resolved);
if (finds) {
const stat = await mz.fs.stat(resolved);
if (
(options.type.hasOwnProperty('d') && stat.isDirectory())
||
(options.type.hasOwnProperty('f') && stat.isFile())
) {
options.results.push({
path: resolved,
dir: stat.isFile() ? path.dirname(resolved) : resolved,
// stat: stat
});
}
}
const foundHit= await mz.fs.readdir(options.root)
const foundHitPromises = [];
await foundHit.forEachAsync(async (foundDir) => {
const resolvedFoundDir = path.resolve(options.root, foundDir);
const stat = await mz.fs.stat(resolvedFoundDir);
if (!stat.isDirectory()) {
return;
}
if (options.find.includes(foundDir) || options.exclude.includes(foundDir)) {
return;
}
const newOptions = Object.assign({}, options)
newOptions.root = resolvedFoundDir;
foundHitPromises.push(multi(newOptions))
})
await Promise.all(foundHitPromises);
})
return options.results;
}
module.exports = async (options) => {
if (typeof options === 'string') {
options = {
find: options
}
}
options.root = options.root || process.cwd();
options.results = options.results || [];
options.type = options.type || {
d: true,
f: true,
};
if (!Array.isArray(options.find)) {
options.find = [options.find];
}
options.find = options.find.map(findable => {
findable= findable.trim();
if (findable.startsWith('./')) {
findable = findable.substr(2);
}
if (findable.endsWith('/')) {
findable = findable.substr(0, findable.length - 1);
}
return findable;
})
if (!options.exclude) {
options.exclude = [];
const excluder = (path) => {
if (!options.find.includes(path)) {
options.exclude.push(path);
}
}
excluder('node_modules')
excluder('bower_components')
}
if (options.dry || options.debug) {
console.log(`Options: ${JSON.stringify(options, null, 2)}`)
}
return await multi(options);
};
src/fs/index.js 0000664 0000000 0000000 00000001355 15167050144 0013731 0 ustar 00root root 0000000 0000000 const fs = require('fs');
const mz = require('mz');
const path = require('path');
const fsExtra = require('fs-extra');
const ensureDir = async (dir) => {
const exists = await mz.fs.exists(dir);
if (exists) {
return;
}
await mz.fs.mkdir(dir);
}
const ensureFile = async(file, defaultData = '') => {
const exists = await mz.fs.exists(file);
if (exists) {
return true;
}
if (typeof(defaultData) === 'object') {
defaultData = JSON.stringify(defaultData);
}
await fsExtra.ensureDir(path.dirname(file));
await mz.fs.writeFile(file, defaultData)
return false;
}
module.exports.ensureFile = ensureFile;
module.exports.ensureDir = ensureDir;
module.exports.find = require('./find'); src/hash.js 0000664 0000000 0000000 00000001146 15167050144 0013133 0 ustar 00root root 0000000 0000000 const fs = require('fs');
const crypto = require('crypto');
const random = require('./random');
const fileHash = async (file, cryptoName = 'sha256') => {
return new Promise((resolve, reject) => {
const fstream = fs.createReadStream(file);
const hash = crypto.createHash(cryptoName);
fstream.on('error', reject);
fstream.on('end', function() {
hash.end();
const bytes = hash.read();
const string = require('./base').charset(bytes)
resolve(string);
});
fstream.pipe(hash);
})
}
module.exports.file = fileHash;
src/http/ 0000775 0000000 0000000 00000000000 15167050144 0012627 5 ustar 00root root 0000000 0000000 src/http/index.js 0000664 0000000 0000000 00000004461 15167050144 0014301 0 ustar 00root root 0000000 0000000 const url = require('url');
module.exports.request = (options) => {
if (typeof(options) === 'string') {
options = {
url: options,
method: 'GET',
}
}
/*
https://nodejs.org/api/http.html#http_http_request_options_callback
*/
const parsedUrl = url.parse(options.url);
let request;
if (parsedUrl.protocol === 'https:') {
request = require('https').request;
if (parsedUrl.port === null) {
parsedUrl.port = 443;
}
} else if (parsedUrl.protocol === 'http:') {
request = require('http').request;
if (parsedUrl.port === null) {
parsedUrl.port = 80;
}
} else {
throw new Error(`Unknown protocol ${parsedUrl.protocol}`);
}
options.protocol = parsedUrl.protocol;
options.port = parsedUrl.port;
options.host = parsedUrl.host;
options.hostname = parsedUrl.hostname;
options.path = parsedUrl.path;
let body;
if (options.body !== undefined) {
if (typeof(options.body) === 'object') {
body = JSON.stringify(options.body);
options.headers = options.headers || {};
if (!options.headers.hasOwnProperty('Content-Type')) {
options.headers['Content-Type'] = 'application/json; charset=utf-8'
options.headers['Content-Length'] = Buffer.byteLength(body)
}
}
}
return new Promise((resolve, reject) => {
const req = request(options, (res) => {
res.setEncoding('utf8');
let rawData = '';
res.on('data', (chunk) => {
rawData += chunk;
});
res.on('end', () => {
try {
if (res.headers.hasOwnProperty('content-type') && res.headers['content-type'].startsWith('application/json')) {
const parsedData = JSON.parse(rawData);
res.body = parsedData;
} else {
res.body = rawData;
}
resolve(res);
} catch (e) {
reject(e);
}
});
})
req.on('error', reject);
if (body !== undefined) {
req.write(body);
}
req.end();
})
} src/index.js 0000664 0000000 0000000 00000001621 15167050144 0013315 0 ustar 00root root 0000000 0000000 module.exports = {
lodash: require('./lodash'),
error: require('./error'),
process: require('./process'),
base: require('./base'),
random: require('./random'),
array: require('./array'),
string: require('./string'),
time: require('./time'),
object: require('./object'),
hash: require('./hash'),
http: require('./http'),
childProcess: require('./child-process'),
promise: require('./promise'),
fs: require('./fs'),
db: require('./db'),
regexp: require('./regexp'),
json: require('./json'),
require: require('./require'),
timer: require('./timer'),
input: require('./input'),
}
const repeat = (count, callback) => {
return [...Array(count).keys()].forEach(callback);
}
repeat.async = async (count, callback, serial) => {
return await [...Array(count).keys()].forEachAsync(callback, serial);
}
module.exports.repeat = repeat; src/input.js 0000664 0000000 0000000 00000000613 15167050144 0013345 0 ustar 00root root 0000000 0000000 const readline = require('readline');
module.exports.key = async (msg = "Press for enter...") => {
return new Promise((resolve, reject) => {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
rl.question(msg, function (answer) {
resolve(answer);
rl.close();
})
})
} src/json.js 0000664 0000000 0000000 00000000270 15167050144 0013156 0 ustar 00root root 0000000 0000000 const cloneDeep = require('lodash/cloneDeep')
module.exports.clone = (obj) => {
if (obj === null || obj === undefined) {
return undefined
}
return cloneDeep(obj);
} src/lodash/ 0000775 0000000 0000000 00000000000 15167050144 0013122 5 ustar 00root root 0000000 0000000 src/lodash/index.js 0000664 0000000 0000000 00000000274 15167050144 0014572 0 ustar 00root root 0000000 0000000 const _ = require('lodash');
_.mixin({ 'pascalCase': _.flow(_.camelCase, _.upperFirst) });
_.dotCase = (name) => {
return _.snakeCase(name).replace(/_/g, '.');
}
module.exports = _; src/object.js 0000664 0000000 0000000 00000000451 15167050144 0013454 0 ustar 00root root 0000000 0000000 module.exports.reduce = (obj, props = ['content'], length = 100) => {
const reduced = Object.assign({}, obj);
if (Array.isArray(props)) {
props = [props];
}
props.forEach((prop) => {
reduced[prop] = reduced[prop].substring(0, length);
})
return reduced;
}
src/process.js 0000664 0000000 0000000 00000001236 15167050144 0013666 0 ustar 00root root 0000000 0000000 process.on("unhandledRejection", (err, promise) => {
if (process.listeners('unhandledRejection').length > 1) {
return;
}
console.error(new Date().toLocaleString(), 'unhandledRejection', err, promise);
process.exit(1);
});
process.on('uncaughtException', function (err) {
if (process.listeners('uncaughtException').length > 1) {
return;
}
console.error(new Date().toLocaleString(), 'uncaughtException', err);
process.exit(1);
});
module.exports.writableCallbackExit = (callback) => {
process.on('exit', function () {
if (!this.stdin._writableState.ended) {
callback(this.stdin)
}
});
} src/promise.js 0000664 0000000 0000000 00000000401 15167050144 0013657 0 ustar 00root root 0000000 0000000 module.exports.deferred = () => {
let resolver, rejecter;
const promise = new Promise((resolve, reject) => { resolver = resolve, rejecter = reject })
return {
resolve: resolver,
reject: rejecter,
promise: promise,
}
} src/random.js 0000664 0000000 0000000 00000000517 15167050144 0013471 0 ustar 00root root 0000000 0000000 const crypto = require('mz/crypto');
module.exports = async(length = 128) => {
const random = await crypto.randomBytes(length);
const string = require('./base').charset(random)
return string;
}
module.exports.integer = (min = 0, max = Int.MAX_INTEGER) => {
return Math.floor(Math.random() * (max - min + 1)) + min;
} src/regexp.js 0000664 0000000 0000000 00000000255 15167050144 0013502 0 ustar 00root root 0000000 0000000 const escape = function(s) {
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
};
if (!RegExp.escape) {
RegExp.escape = escape;
}
module.exports.escape = escape; src/require.js 0000664 0000000 0000000 00000005722 15167050144 0013670 0 ustar 00root root 0000000 0000000 const resovleDependencies =(options) => {
if (Array.isArray(options)) {
options = {
modules: options
}
}
let {
modules,
recursive,
debug
} = options;
recursive = recursive || [];
if (debug) {
dconsole = console;
} else {
dconsole = {
info: () => {},
}
}
let resovledModules = [];
let lastWrongModule;
let iteration = 0;
dconsole.info(`Modules: ${modules.length}`);
const ensureWants = () => {
iteration++;
dconsole.info();
dconsole.info(`Iteration: ${iteration}`)
let totalOk = true;
for(let index = 0 ; index < modules.length; index++) {
const loadedModule = modules[index];
dconsole.info();
dconsole.info(`Module: ${loadedModule.name}`);
if (recursive.includes(loadedModule.name) ) {
if (!resovledModules.includes(loadedModule)) {
dconsole.info(`Adding to the recursived list`);
resovledModules.push(loadedModule);
}
}
if (resovledModules.includes(loadedModule)) {
dconsole.info(`Already got it`);
continue;
}
let ok = true
loadedModule.wants.forEach((want) => {
let found = false;
resovledModules.forEach((resultModule) => {
if (resultModule.name === want ) {
found = true;
}
})
if (!found) {
ok = false;
totalOk = false;
}
})
if (ok) {
dconsole.info(`Found!`);
resovledModules.push(loadedModule);
} else {
lastWrongModule = {
name: loadedModule.name,
wants: loadedModule.wants
}
}
}
return totalOk;
}
let checkCircular;
while(!ensureWants()) {
if (checkCircular === undefined) {
checkCircular = resovledModules.length;
continue;
}
if (checkCircular === resovledModules.length) {
const print = (datas) => {
return JSON.stringify(datas.map((data) => {
return {
name: data.name,
wants: data.wants
}
}), null, 2)
}
dconsole.info(`
Loaded factories
`, print(modules))
dconsole.info(`
Wanted factories in order
`, print(resovledModules));
dconsole.info(`
Last wrong factory
`, lastWrongModule);
dconsole.info(`
`)
throw Error('circular loading factory');
}
checkCircular = resovledModules.length;
}
return resovledModules;
}
module.exports.resovleDependencies = resovleDependencies; src/string/ 0000775 0000000 0000000 00000000000 15167050144 0013156 5 ustar 00root root 0000000 0000000 src/string/index.js 0000664 0000000 0000000 00000003044 15167050144 0014624 0 ustar 00root root 0000000 0000000 if (!String.prototype.padStart) {
String.prototype.padStart = function padStart(targetLength,padString) {
targetLength = targetLength>>0; //floor if number or convert non-number to 0;
padString = String(padString || ' ');
if (this.length > targetLength) {
return String(this);
}
else {
targetLength = targetLength-this.length;
if (targetLength > padString.length) {
padString += padString.repeat(targetLength/padString.length); //append to original to ensure we are longer than needed
}
return padString.slice(0,targetLength) + String(this);
}
};
}
module.exports.empty = (spec) => {
spec = String(spec).trim();
return spec === undefined || spec === '' || spec === 'undefined'
}
module.exports.inject = (str, options) => {
const findPrefix = str.indexOf(options.prefix);
const postixIndex = str.indexOf(options.postfix);
if (findPrefix == -1 && postixIndex == -1 && !options.header && !options.footer) {
return;
}
if (findPrefix == -1 && postixIndex == -1 ) {
let replaceText = options.prefix + '\n' + options.replace + '\n' + options.postfix;
if (options.header) {
str = replaceText + '\n' +str;
} else {
str += '\n' + replaceText;
}
} else {
const prefixIndex = findPrefix + options.prefix.length;
str = str.substring(0, prefixIndex) + '\n' + options.replace + '\n' + str.substring(postixIndex);
}
return str;
}
src/time.js 0000664 0000000 0000000 00000001102 15167050144 0013136 0 ustar 00root root 0000000 0000000 const ms = require('ms');
const timestring = require('timestring');
module.exports.span = (spec) => {
let result = timestring(spec);
if (typeof(result) === 'number') {
result = result * 1000;
}
return result;
}
module.exports.verbose = (timestamp, started) => {
if (timestamp === undefined) {
return undefined;
}
return {
left: ms(timestamp - Date.now()),
end: new Date(timestamp).toLocaleString(),
start: new Date(started).toLocaleString(),
startstamp: started,
timestamp: timestamp,
}
} src/timer.js 0000664 0000000 0000000 00000001673 15167050144 0013335 0 ustar 00root root 0000000 0000000 const promiseUtils = require('./promise');
const wait = async(timeout) => {
return await corySetTimeout(timeout);
}
const corySetTimeout = async (cb, timeout) => {
if (timeout === undefined) {
timeout = cb;
cb = () => {};
}
const { resolve, reject, promise} = promiseUtils.deferred();
promise.timer = setTimeout(async () => {
try {
await cb();
resolve();
} catch (e) {
reject(e);
}
}, timeout)
return promise;
}
const corySetInterval = async(cb, timeout) => {
const { resolve, reject, promise} = promiseUtils.deferred();
promise.timer = setInterval(async() => {
try {
await cb();
resolve();
} catch (e) {
reject(e);
}
}, timeout)
return promise;
}
module.exports.wait = wait;
module.exports.setTimeout = corySetTimeout;
module.exports.setInterval = corySetInterval ; test/ 0000775 0000000 0000000 00000000000 15167050144 0012040 5 ustar 00root root 0000000 0000000 test/script/ 0000775 0000000 0000000 00000000000 15167050144 0013344 5 ustar 00root root 0000000 0000000 test/script/error.js 0000775 0000000 0000000 00000000066 15167050144 0015040 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
require('../../src');
throw 400; test/script/hash.js 0000775 0000000 0000000 00000000262 15167050144 0014630 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utils = require('../../src');
const start = async() => {
const hash = await utils.hash.file('./package.json');
console.log(hash);
}
start(); test/script/json-clone.js 0000775 0000000 0000000 00000000240 15167050144 0015750 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utils = require('../../src');
const obj = {
a: 1,
b: 2,
}
const obj2 = utils.json.clone(obj);
obj.a = 2;
console.log(obj2) test/script/last-day.js 0000775 0000000 0000000 00000000761 15167050144 0015427 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utils = require('../../src');
console.log(new Date(utils.time.lastDay(0)).toLocaleString());
console.log(new Date(utils.time.lastDay(1)).toLocaleString());
console.log(new Date(utils.time.lastDay(2)).toLocaleString());
console.log(new Date(utils.time.lastDay(3)).toLocaleString());
console.log(new Date(utils.time.lastDay(4)).toLocaleString());
console.log(new Date(utils.time.lastDay(5)).toLocaleString());
console.log(new Date(utils.time.lastDay(6)).toLocaleString());
test/script/random.js 0000775 0000000 0000000 00000000246 15167050144 0015167 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utils = require('../../src');
const start = async() => {
const random = await utils.random(128);
console.log(random);
}
start();