.gitignore 0000664 0000000 0000000 00000000115 15170161502 0013041 0 ustar 00root root 0000000 0000000 /build
/node_modules
/*.log
/yarn.lock
.idea/workspace.xml
.idea/tasks.xml
.idea/ 0000775 0000000 0000000 00000000000 15170161502 0012034 5 ustar 00root root 0000000 0000000 .idea/corifeus-utils.iml 0000664 0000000 0000000 00000000520 15170161502 0015511 0 ustar 00root root 0000000 0000000
.idea/modules.xml 0000664 0000000 0000000 00000000430 15170161502 0014223 0 ustar 00root root 0000000 0000000
.idea/vcs.xml 0000664 0000000 0000000 00000000247 15170161502 0013354 0 ustar 00root root 0000000 0000000
.npmignore 0000664 0000000 0000000 00000000222 15170161502 0013047 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 15170161502 0014244 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 15170161502 0013162 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 15170161502 0013345 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 15170161502 0012056 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 00000006004 15170161502 0012333 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.***
### Node Version Requirement
```
>=7.8.0
```
### Built on Node
```
v7.10.0
```
The ```async``` and ```await``` keywords are required.
Install NodeJs:
https://nodejs.org/en/download/package-manager/
# 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
* base62
* promise
* extract
* process
* unhandledRejection
* uncaughtException
* writableCallbackExit
* object
* reduce
* hash
* file
* string
* padStart
* empty
* inject
* lodash
* PascalCase
* http
* request
* db
* file based
* child-process
* exec, romise
* array
* for each async
# Promisefy
https://github.com/digitaldesignlabs/es6-promisify
[//]: #@corifeus-footer
---
[**CORIFEUS-UTILS**](https://pages.corifeus.tk/corifeus-utils) Build v1.1.271-56
[Corifeus](http://www.corifeus.tk) by [Patrik Laszlo](http://patrikx3.tk)
[//]: #@corifeus-footer:end
corifeus-utils.iml 0000664 0000000 0000000 00000000517 15170161502 0014537 0 ustar 00root root 0000000 0000000
package.json 0000664 0000000 0000000 00000002273 15170161502 0013346 0 ustar 00root root 0000000 0000000 {
"name": "corifeus-utils",
"version": "1.1.271-56",
"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.606-50"
},
"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 15170161502 0011643 5 ustar 00root root 0000000 0000000 src/array/ 0000775 0000000 0000000 00000000000 15170161502 0012761 5 ustar 00root root 0000000 0000000 src/array/for-each-async.js 0000664 0000000 0000000 00000001177 15170161502 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];
if (serial) {
if (lastCb === undefined) {
lastCb = cb(item);
} else {
lastCb = lastCb.then(() => cb(item));
}
} else {
promises.push(cb(item))
}
}
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 00000000612 15170161502 0014425 0 ustar 00root root 0000000 0000000 module.exports.forEachAsync = require('./for-each-async');
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 15170161502 0013121 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 15170161502 0014402 5 ustar 00root root 0000000 0000000 src/child-process/index.js 0000664 0000000 0000000 00000001630 15170161502 0016047 0 ustar 00root root 0000000 0000000 const childProcess = require('child_process');
const promisable = 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} = promisable.extract();
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 15170161502 0012230 5 ustar 00root root 0000000 0000000 src/db/index.js 0000664 0000000 0000000 00000002644 15170161502 0013703 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 15170161502 0013335 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.js 0000664 0000000 0000000 00000001340 15170161502 0012607 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 await mz.fs.readFile(file);
}
if (typeof(defaultData) === 'object') {
defaultData = JSON.stringify(defaultData);
}
await fsExtra.ensureDir(path.dirname(file));
await mz.fs.writeFile(file, defaultData)
return defaultData;
}
module.exports.ensureFile = ensureFile;
module.exports.ensureDir = ensureDir; src/hash.js 0000664 0000000 0000000 00000001146 15170161502 0013126 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 15170161502 0012622 5 ustar 00root root 0000000 0000000 src/http/index.js 0000664 0000000 0000000 00000004350 15170161502 0014271 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;
}
resolve(res);
} catch (e) {
reject(e);
}
});
})
req.on('error', reject);
if (body !== undefined) {
req.write(body);
}
req.end();
})
} src/index.js 0000664 0000000 0000000 00000001353 15170161502 0013312 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'),
}
const repeat = async (count, callback, serial) => {
return await new Array(count).forEachAsync(callback, serial);
}
module.exports.repeat = repeat; src/json.js 0000664 0000000 0000000 00000000222 15170161502 0013146 0 ustar 00root root 0000000 0000000 module.exports.clone = (obj) => {
if (obj === null || obj === undefined) {
return undefined
}
return Object.assign({}, obj);
} src/lodash/ 0000775 0000000 0000000 00000000000 15170161502 0013115 5 ustar 00root root 0000000 0000000 src/lodash/index.js 0000664 0000000 0000000 00000000274 15170161502 0014565 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 15170161502 0013447 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 15170161502 0013661 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 00000000400 15170161502 0013651 0 ustar 00root root 0000000 0000000 module.exports.extract = () => {
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 00000000321 15170161502 0013455 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;
}
src/regexp.js 0000664 0000000 0000000 00000000255 15170161502 0013475 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 00000005663 15170161502 0013667 0 ustar 00root root 0000000 0000000 const resovleDependencies =(options) => {
if (Array.isArray(options)) {
options = {
modules: options
}
}
const {
modules,
recursive,
debug
} = options;
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 15170161502 0013151 5 ustar 00root root 0000000 0000000 src/string/index.js 0000664 0000000 0000000 00000003044 15170161502 0014617 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 00000001114 15170161502 0013134 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 = Date.now()) => {
if (timestamp === undefined) {
return undefined;
}
return {
left: ms(timestamp - started),
end: new Date(timestamp).toLocaleString(),
start: new Date(started).toLocaleString(),
startstamp: started,
timestamp: timestamp,
}
} test/ 0000775 0000000 0000000 00000000000 15170161502 0012033 5 ustar 00root root 0000000 0000000 test/script/ 0000775 0000000 0000000 00000000000 15170161502 0013337 5 ustar 00root root 0000000 0000000 test/script/error.js 0000775 0000000 0000000 00000000104 15170161502 0015024 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
require('../../src');
throw new Error('hiba'); test/script/hash.js 0000775 0000000 0000000 00000000262 15170161502 0014623 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 15170161502 0015743 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 15170161502 0015422 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 15170161502 0015162 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();