.gitignore 0000664 0000000 0000000 00000000351 15165344447 0013062 0 ustar 00root root 0000000 0000000 /build
/node_modules
/*.log
.idea/workspace.xml
.idea/tasks.xml
.idea/profiles_settings.xml
.idea/inspectionProfiles/Project_Default.xml
.idea/inspectionProfiles/profiles_settings.xml
node_modules/.yarn-integrity
package-lock.json
.idea/ 0000775 0000000 0000000 00000000000 15165344447 0012053 5 ustar 00root root 0000000 0000000 .idea/codeStyleSettings.xml 0000664 0000000 0000000 00000000425 15165344447 0016252 0 ustar 00root root 0000000 0000000
.idea/corifeus-utils.iml 0000664 0000000 0000000 00000000520 15165344447 0015530 0 ustar 00root root 0000000 0000000
.idea/misc.xml 0000664 0000000 0000000 00000000256 15165344447 0013533 0 ustar 00root root 0000000 0000000
.idea/modules.xml 0000664 0000000 0000000 00000000430 15165344447 0014242 0 ustar 00root root 0000000 0000000
.idea/php.xml 0000664 0000000 0000000 00000000330 15165344447 0013360 0 ustar 00root root 0000000 0000000
.idea/vcs.xml 0000664 0000000 0000000 00000000247 15165344447 0013373 0 ustar 00root root 0000000 0000000
.npmignore 0000664 0000000 0000000 00000000222 15165344447 0013066 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 00000001006 15165344447 0014252 0 ustar 00root root 0000000 0000000 checks:
javascript: true
filter:
excluded_paths:
- test/*
- node_modules/*
- build/*
- docs/*
build:
cache:
disabled: true
environment:
google_chrome:
use_latest: true
dependencies:
before:
- export LATEST=$(nvm ls-remote | tail -1)
- nvm install $LATEST
# - nvm use $LATEST
- npm install -g grunt-cli
tests:
override:
-
command: 'grunt'
coverage:
file: 'build/coverage/clover.xml'
format: 'clover'
.travis.yml 0000664 0000000 0000000 00000000123 15165344447 0013200 0 ustar 00root root 0000000 0000000 language: node_js
node_js:
- "node"
before_script:
- npm install grunt-cli -g
Gruntfile.js 0000664 0000000 0000000 00000000420 15165344447 0013364 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 00000002141 15165344447 0012076 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2017 Patrik Laszlo / patrikx3 / https://patrikx3.com 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 00000007524 15165344447 0012362 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 v1.1.769-267
This is an open source project. Just code. If you like this code, please add a star in GitHub and you really like, you can donate as well. Thanks you so much!
Given, I have my own server, with dynamic IP address, it could happen that the server for about max 5 minutes can not be reachable for the dynamic DNS or very rarely I backup with Clonzilla the SSD or something with the electricity (too much hoovering or cleaning - but I worked on it, so should not happen again), but for some reason, it is not reachable please hang on for 5-30 minutes and it will be back for sure.
All my domains (patrikx3.com and corifeus.com) could have errors right now, since I am developing in my free time and you can catch glitches, but usually it is stable (imagine updating everything always, which is weird).
### Node Version Requirement
```
>=8.9.0
```
### Built on Node
```
v9.4.0
```
The ```async``` and ```await``` keywords are required.
Install NodeJs:
https://nodejs.org/en/download/package-manager/
undefined
# 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)
* complexUuid
* 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/await for each
[//]: #@corifeus-footer
---
[**CORIFEUS-UTILS**](https://pages.corifeus.com/corifeus-utils) Build v1.1.769-267
[](https://www.facebook.com/corifeus.software) [](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=LFRV89WPRMMVE&lc=HU&item_name=Patrik%20Laszlo&item_number=patrikx3¤cy_code=HUF&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHosted) [](https://www.patrikx3.com/en/front/contact)
[//]: #@corifeus-footer:end
corifeus-utils.iml 0000664 0000000 0000000 00000000517 15165344447 0014556 0 ustar 00root root 0000000 0000000
package.json 0000664 0000000 0000000 00000002357 15165344447 0013370 0 ustar 00root root 0000000 0000000 {
"name": "corifeus-utils",
"version": "1.1.769-267",
"corifeus": {
"icon": "fa fa-lightbulb-o",
"code": "Memory",
"publish": true,
"nodejs": "v9.4.0"
},
"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.com/corifeus-utils",
"devDependencies": {
"corifeus-builder": "^1.7.1138-274"
},
"dependencies": {
"fs-extra": "^5.0.0",
"glob": "^7.1.2",
"lodash": "^4.17.4",
"ms": "^2.1.1",
"mz": "^2.7.0",
"timestring": "^5.0.0",
"uuid": "^3.2.1"
},
"engines": {
"node": ">=8.9.0"
}
} src/ 0000775 0000000 0000000 00000000000 15165344447 0011662 5 ustar 00root root 0000000 0000000 src/array/ 0000775 0000000 0000000 00000000000 15165344447 0013000 5 ustar 00root root 0000000 0000000 src/array/for-each-async.js 0000664 0000000 0000000 00000001334 15165344447 0016136 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 15165344447 0014455 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 00000001172 15165344447 0013133 0 ustar 00root root 0000000 0000000 const base62Charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
const base36Charset = 'abcdefghijklmnopqrstuvwxyz0123456789';
module.exports.base36Charset = base36Charset;
module.exports.base62Charset = base62Charset;
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 15165344447 0014421 5 ustar 00root root 0000000 0000000 src/child-process/index.js 0000664 0000000 0000000 00000001633 15165344447 0016071 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 15165344447 0012247 5 ustar 00root root 0000000 0000000 src/db/index.js 0000664 0000000 0000000 00000002761 15165344447 0013722 0 ustar 00root root 0000000 0000000 const coryFs = require('../fs');
const mz = require('mz');
const load = async (dbFile, data = {}) => {
const exists = await coryFs.ensureFile(dbFile, data)
if (exists) {
data = await mz.fs.readFile(dbFile);
}
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 15165344447 0013354 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 15165344447 0012272 5 ustar 00root root 0000000 0000000 src/fs/find.js 0000664 0000000 0000000 00000005175 15165344447 0013560 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 00000003567 15165344447 0013752 0 ustar 00root root 0000000 0000000 const fs = require('fs');
const mz = require('mz');
const path = require('path');
const fsExtra = require('fs-extra');
const os = require('os');
const tmp = os.tmpdir();
const random = require('../random');
const ensureDir = async (dir) => {
const exists = await mz.fs.exists(dir);
if (exists) {
return;
}
await fsExtra.ensureDir(dir);
}
const ensureFile = async(file, defaultData = '', alwaysWrite = false) => {
const exists = await mz.fs.exists(file);
if (exists && !alwaysWrite) {
return true;
}
if (typeof(defaultData) === 'object') {
defaultData = JSON.stringify(defaultData);
}
await fsExtra.ensureDir(path.dirname(file));
await mz.fs.writeFile(file, defaultData)
return false;
}
const createWriteStream = (filename) => {
const stream = fs.createWriteStream(filename);
const promise = new Promise((resolve, reject) => {
stream.on('finish', async() => {
resolve();
});
stream.on('error', (error) => {
reject(error);
});
})
promise.stream = stream;
return promise;
}
const tempFileName = async (extension = 'tmp') => {
const randomFile = 'tmp-' + Date.now() +'-' + await random.lower();
const randomFileFinal = `${tmp}/${randomFile}.${extension}`
if (await mz.fs.exists(randomFileFinal)) {
return await tempFileName(extension);
}
return randomFileFinal;
}
const ensureTempFile = async (data, extension = 'tmp') => {
const randomFileFinal = await tempFileName(extension);
await mz.fs.writeFile(randomFileFinal, data);
return randomFileFinal;
}
module.exports.ensureFile = ensureFile;
module.exports.ensureDir = ensureDir;
module.exports.find = require('./find');
module.exports.ensureTempFile = ensureTempFile;
module.exports.tempFileName = tempFileName;
module.exports.createWriteStream = createWriteStream; src/hash.js 0000664 0000000 0000000 00000001415 15165344447 0013144 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);
})
}
const stringHash = (string, cryptoName = 'sha256') => {
return crypto.createHash(cryptoName).update(string).digest("hex");
}
module.exports.string= stringHash;
module.exports.file = fileHash;
src/http/ 0000775 0000000 0000000 00000000000 15165344447 0012641 5 ustar 00root root 0000000 0000000 src/http/index.js 0000664 0000000 0000000 00000000060 15165344447 0014302 0 ustar 00root root 0000000 0000000
module.exports.request = require('./request');
src/http/request.js 0000664 0000000 0000000 00000006346 15165344447 0014700 0 ustar 00root root 0000000 0000000 const url = require('url');
const coryRequest = (options) => {
if (typeof(options) === 'string') {
options = {
url: options,
}
}
const originalOptions = Object.assign({}, options)
/*
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;
options.headers = options.headers || {};
if (options.body !== undefined) {
if (typeof(options.body) === 'object') {
body = JSON.stringify(options.body);
if (!options.headers.hasOwnProperty('Content-Type')) {
options.headers['Content-Type'] = 'application/json; charset=utf-8'
options.headers['Content-Length'] = Buffer.byteLength(body)
}
}
}
if (!options.headers.hasOwnProperty('User-Agent')) {
options.headers['User-Agent'] = 'Corifeus-Utils-Request';
}
if (!options.hasOwnProperty('method')) {
options.method = 'GET';
}
const promise = new Promise((resolve, reject) => {
try {
const req = request(options, (response) => {
if (response.headers.hasOwnProperty('location')) {
req.end();
originalOptions.url = response.headers.location;
return resolve(coryRequest(originalOptions));
}
if (options.hasOwnProperty('pipe') && options.pipe === true) {
resolve(response);
return;
}
response.setEncoding('utf8');
let rawData = '';
response.on('data', (chunk) => {
rawData += chunk;
});
response.on('end', () => {
try {
if (response.headers.hasOwnProperty('content-type') && response.headers['content-type'].startsWith('application/json')) {
const parsedData = JSON.parse(rawData);
response.body = parsedData;
} else {
response.body = rawData;
}
resolve(response);
} catch (e) {
reject(e);
}
});
})
req.on('error', reject);
if (body !== undefined) {
req.write(body);
}
req.end();
} catch (e) {
console.error(e);
reject(e);
}
})
return promise;
}
module.exports = coryRequest; src/index.js 0000664 0000000 0000000 00000001723 15165344447 0013332 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'),
network: require('./network'),
redis: require('./redis'),
}
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 15165344447 0013357 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 15165344447 0013170 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 15165344447 0013134 5 ustar 00root root 0000000 0000000 src/lodash/index.js 0000664 0000000 0000000 00000000274 15165344447 0014604 0 ustar 00root root 0000000 0000000 const _ = require('lodash');
_.mixin({ 'pascalCase': _.flow(_.camelCase, _.upperFirst) });
_.dotCase = (name) => {
return _.snakeCase(name).replace(/_/g, '.');
}
module.exports = _; src/network.js 0000664 0000000 0000000 00000002605 15165344447 0013714 0 ustar 00root root 0000000 0000000 const utilsPromise = require('./promise');
module.exports.waitPort = async (options) => {
let {
port, host, retry, wait
} = options
if (port === undefined) {
throw new Error(`${port} is undefined, please select a port like 25, 80 etc...`)
}
retry = retry || 8
wait = wait || 3000
host = host || '127.0.0.1';
let actualRetry = 0;
const { reject, resolve , promise } = utilsPromise.deferred();
const checkPort = () => {
actualRetry++;
const net = require('net');
const server = net.createServer();
server.once('error', function(err) {
if (err.code === 'EADDRINUSE') {
// port is currently in use
console.info(`Port ${port} in ${host} is opened`);
server.close();
clearInterval(interval);
resolve();
}
});
server.once('listening', function() {
// close the server if listening doesn't fail
console.info(`Retry ${actualRetry}, Port ${port} in ${host} is not opened`);
server.close();
if (actualRetry > retry) {
reject();
}
});
server.listen({
host: 'localhost',
port: port,
});
}
const interval = setInterval(checkPort, wait)
checkPort();
return promise;
} src/object.js 0000664 0000000 0000000 00000000451 15165344447 0013466 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 15165344447 0013700 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 15165344447 0013671 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 00000001440 15165344447 0013477 0 ustar 00root root 0000000 0000000 const crypto = require('mz/crypto');
const uuid = require('uuid');
module.exports = async(length = 128) => {
const random = await crypto.randomBytes(length);
const string = require('./base').charset(random)
return string;
}
module.exports.timeBase = async(length = 128) => {
let random = await module.exports (length)
return `${Date.now()}${random}`;
}
module.exports.integer = (min = 0, max = Int.MAX_INTEGER) => {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
module.exports.lower = async(length = 16) => {
const random = await crypto.randomBytes(length);
const base = require('./base');
const string = base.charset(random, base.base36Charset)
return string;
}
module.exports.complexUuid = () => {
return `${uuid.v4()}-${uuid.v1()}`
} src/redis.js 0000664 0000000 0000000 00000000603 15165344447 0013325 0 ustar 00root root 0000000 0000000 module.exports.parseUrl = (redisUrlInput) => {
const url = require('url');
const redisUrl = new url.URL(redisUrlInput);
const redisObject = {
"password": redisUrl.password,
"port": redisUrl.port || 6379,
"host": redisUrl.hostname,
"db": redisUrl.pathname.length > 1 ? parseInt(redisUrl.pathname.substr(1)) : 0,
};
return redisObject;
} src/regexp.js 0000664 0000000 0000000 00000000255 15165344447 0013514 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 15165344447 0013702 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 15165344447 0013170 5 ustar 00root root 0000000 0000000 src/string/index.js 0000664 0000000 0000000 00000003044 15165344447 0014636 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 00000002076 15165344447 0013163 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.msParse = (ms) => {
if (typeof ms !== 'number') {
throw new TypeError('Expected a number');
}
var roundTowardZero = ms > 0 ? Math.floor : Math.ceil;
return {
days: roundTowardZero(ms / 86400000),
hours: roundTowardZero(ms / 3600000) % 24,
minutes: roundTowardZero(ms / 60000) % 60,
seconds: roundTowardZero(ms / 1000) % 60,
milliseconds: roundTowardZero(ms) % 1000
};
};
module.exports.verbose = (timestamp, started) => {
if (timestamp === undefined) {
return undefined;
}
const leftMs = timestamp - Date.now();
return {
left: ms(leftMs),
leftMs: leftMs,
end: new Date(timestamp).toLocaleString(),
start: new Date(started).toLocaleString(),
startstamp: started,
timestamp: timestamp,
}
} src/timer.js 0000664 0000000 0000000 00000003416 15165344447 0013344 0 ustar 00root root 0000000 0000000 const promiseUtils = require('./promise');
const fsExtra = require('fs-extra');
const os = require('os');
const mzFs = require('mz/fs');
const hash = require('./hash');
const path = require('path');
const wait = async(timeout) => {
return await corySetTimeout(timeout);
}
const waitFile = async(timeout = 20000, file) => {
if (file === undefined) {
file = `${os.tmpdir()}/p3x-wait-file-${path.parse(process.argv[1]).name}-${hash.string(process.argv.join())}.boot`
}
const exists = await fsExtra.pathExists(file);
if (exists) {
console.info(`${file} exists, no delay required`);
} else {
console.info(`${file} doesn't exist, waiting ${timeout}ms, then generate ${file}`);
await wait(timeout);
console.info(`${file} now exists`);
}
await mzFs.writeFile(file, Date.now());
return {
timeout: timeout,
file: file,
exists: exists,
}
}
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.waitFile = waitFile;
module.exports.setTimeout = corySetTimeout;
module.exports.setInterval = corySetInterval ; test/ 0000775 0000000 0000000 00000000000 15165344447 0012052 5 ustar 00root root 0000000 0000000 test/script/ 0000775 0000000 0000000 00000000000 15165344447 0013356 5 ustar 00root root 0000000 0000000 test/script/complex-uuid.js 0000664 0000000 0000000 00000000114 15165344447 0016323 0 ustar 00root root 0000000 0000000 const utils = require('../../src');
console.log(utils.random.complexUuid()) test/script/error.js 0000775 0000000 0000000 00000000066 15165344447 0015052 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
require('../../src');
throw 400; test/script/hash-string.js 0000775 0000000 0000000 00000000430 15165344447 0016143 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utils = require('../../src');
const start = async() => {
const hash = await utils.hash.string(process.argv[2]);
console.log(hash);
if (process.argv[3] === 'delay') {
await utils.timer.waitFile();
return;
}
}
start(); test/script/hash.js 0000775 0000000 0000000 00000000262 15165344447 0014642 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 15165344447 0015762 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 15165344447 0015441 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/port-open.js 0000775 0000000 0000000 00000000274 15165344447 0015645 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utls = require('../../src');
const start = async () => {
await utls.network.waitPort({
port: 6379,
hostname: '127.0.0.1',
})
}
start(); test/script/random.js 0000775 0000000 0000000 00000000246 15165344447 0015201 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(); test/script/wait-file.js 0000775 0000000 0000000 00000000305 15165344447 0015576 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const utils = require('../../src');
const start = async() => {
if (process.argv[2] === 'delay') {
await utils.timer.waitFile();
return;
}
}
start();