@makano/rew 1.1.8 → 1.1.9

package/lib/rew/functions/core.js

@@ -1,86 +1,84 @@
-
-
 function isEmpty(value) {
-  if (Array.isArray(value) || typeof value === 'string') {
-    return value.length === 0;
-  } else if (typeof value === 'object') {
-    return Object.keys(value).length === 0;
-  } else {
-    return true;
-  }
+	if (Array.isArray(value) || typeof value === 'string') {
+		return value.length === 0;
+	} else if (typeof value === 'object') {
+		return Object.keys(value).length === 0;
+	} else {
+		return true;
+	}
 }
 
 function clone(value) {
-  if (Array.isArray(value)) {
-    return value.slice();
-  } else if (typeof value === 'object') {
-    return Object.assign({}, value);
-  } else {
-    return value;
-  }
+	if (Array.isArray(value)) {
+		return value.slice();
+	} else if (typeof value === 'object') {
+		return Object.assign({}, value);
+	} else {
+		return value;
+	}
 }
 
 function deepClone(value) {
-  if (Array.isArray(value)) {
-    return value.map(item => deepClone(item));
-  } else if (typeof value === 'object') {
-    const obj = {};
-    for (const key in value) {
-      if (value.hasOwnProperty(key)) {
-        obj[key] = deepClone(value[key]);
-      }
-    }
-    return obj;
-  } else {
-    return value;
-  }
+	if (Array.isArray(value)) {
+		return value.map((item) => deepClone(item));
+	} else if (typeof value === 'object') {
+		const obj = {};
+		for (const key in value) {
+			if (value.hasOwnProperty(key)) {
+				obj[key] = deepClone(value[key]);
+			}
+		}
+		return obj;
+	} else {
+		return value;
+	}
 }
 
 function merge(obj1, obj2) {
-  return Object.assign({}, obj1, obj2);
+	return Object.assign({}, obj1, obj2);
 }
 
 const uniqueId = (() => {
-  let id = 0;
-  return () => {
-    id += 1;
-    return `id-${id}`;
-  };
+	let id = 0;
+	return () => {
+		id += 1;
+		return `id-${id}`;
+	};
 })();
 
 function filter(arr, fn) {
-  return arr.filter(fn);
+	return arr.filter(fn);
 }
 
 function reduce(arr, fn, initial) {
-  return arr.reduce(fn, initial);
+	return arr.reduce(fn, initial);
 }
 
 function compose(...fns) {
-  return initialValue => {
-    return fns.reduceRight((acc, fn) => fn(acc), initialValue);
-  };
+	return (initialValue) => {
+		return fns.reduceRight((acc, fn) => fn(acc), initialValue);
+	};
 }
 
 function curry(fn) {
-  const curried = (...args) => {
-    if (args.length >= fn.length) {
-      return fn.apply(null, args);
-    } else {
-      return (...moreArgs) => curried.apply(null, args.concat(moreArgs));
-    }
-  };
-  return curried;
+	const curried = (...args) => {
+		if (args.length >= fn.length) {
+			return fn.apply(null, args);
+		} else {
+			return (...moreArgs) => curried.apply(null, args.concat(moreArgs));
+		}
+	};
+	return curried;
 }
 
 module.exports = {
-  isEmpty,
-  clone,
-  deepClone,
-  merge,
-  uniqueId,
-  filter,
-  reduce,
-  compose,
-  curry
+	isEmpty,
+	clone,
+	deepClone,
+	merge,
+	uniqueId,
+	filter,
+	reduce,
+	compose,
+	curry,
 };

package/lib/rew/functions/curl.js

@@ -0,0 +1,23 @@
+const future = require("./future");
+const fs = require('fs');
+
+module.exports.curl = function curl(options, url){
+  if(typeof options == 'string'){
+    let newurl = options;
+    options = typeof url == "object" ? url : {};
+    url = newurl;
+  }
+  if(options.url && !url){
+    url = options.url
+  }
+  const method = options.x || "GET";
+  const f = future.promise(fetch(url, {
+    ...options,
+    method
+  }).then(async r => {
+    if(options.o) fs.writeFileSync(options.o, Buffer.from(await r.clone().arrayBuffer()));
+    return r;
+  }).then(r => options.json ? r.clone().json() : r));
+  if(options.a) return f.wait();
+  else return f;
+}

package/lib/rew/functions/emitter.js

@@ -1,57 +1,54 @@
 module.exports = function emitter() {
-  const events = [];
-  const on = (event, callback, props = {}) => {
-    const addEvent = (event) => events.push({ ...props, event, callback });
-    if (Array.isArray(event)) {
-      event.forEach(addEvent);
-    } else {
-      addEvent(event);
-    }
-    return listener;
-  };
-  const off = (event, callback, removable = null) => {
-    const rm = (event) => {
-      if(removable){
-        removable(event);
-      }
-      events.splice(events.indexOf(event), 1);
-    }
-    const rmEvent = (event) => {
-      if (callback) {
-        const _events = events.filter(({ callback: c }) => c == callback);
-        _events.forEach((e) => {
-          if (Array.isArray(event)) {
-            if (event.includes(e.event)) rm(e);
-          } else {
-            if (e.event == event) rm(e);
-          }
-        });
-      } else {
-        const _events = events.filter(({ event: e }) => e == event);
-        _events.forEach((e) => {
-          rm(e);
-        });
-      }
-    };
-    if (Array.isArray(event)) {
-      event.forEach(rmEvent);
-    } else {
-      rmEvent(event);
-    }
-    return listener;
-  };
-  const emit = (event, ...data) => {
-    const emitEvent = (event) =>
-      events
-        .filter(({ event: e }) => e == event)
-        .forEach(({ callback }) => callback(...data));
-    if (Array.isArray(event)) {
-      event.forEach(emitEvent);
-    } else {
-      emitEvent(event);
-    }
-    return listener;
-  };
-  const listener = { on, off, emit };
-  return listener;
+	const events = [];
+	const on = (event, callback, props = {}) => {
+		const addEvent = (event) => events.push({ ...props, event, callback });
+		if (Array.isArray(event)) {
+			event.forEach(addEvent);
+		} else {
+			addEvent(event);
+		}
+		return listener;
+	};
+	const off = (event, callback, removable = null) => {
+		const rm = (event) => {
+			if (removable) {
+				removable(event);
+			}
+			events.splice(events.indexOf(event), 1);
+		};
+		const rmEvent = (event) => {
+			if (callback) {
+				const _events = events.filter(({ callback: c }) => c == callback);
+				_events.forEach((e) => {
+					if (Array.isArray(event)) {
+						if (event.includes(e.event)) rm(e);
+					} else {
+						if (e.event == event) rm(e);
+					}
+				});
+			} else {
+				const _events = events.filter(({ event: e }) => e == event);
+				_events.forEach((e) => {
+					rm(e);
+				});
+			}
+		};
+		if (Array.isArray(event)) {
+			event.forEach(rmEvent);
+		} else {
+			rmEvent(event);
+		}
+		return listener;
+	};
+	const emit = (event, ...data) => {
+		const emitEvent = (event) => events.filter(({ event: e }) => e == event).forEach(({ callback }) => callback(...data));
+		if (Array.isArray(event)) {
+			event.forEach(emitEvent);
+		} else {
+			emitEvent(event);
+		}
+		return listener;
+	};
+	const listener = { on, off, emit };
+	return listener;
 };

package/lib/rew/functions/exec.js

@@ -1,27 +1,31 @@
 const shell = require('child_process');
 
-
 module.exports = (currentFile) => {
+	function exec(command, options) {
+		return shell.execSync(command, {
+			stdio: options?.output == false ? null : 'inherit',
+		});
+	}
 
-  function exec(command, options){
-    return shell.execSync(command, { stdio: options?.output == false ? null : 'inherit' });
-  }
-
-  exec.background = function execAsync(command, options, callback){
-    if(typeof options == "function" && !callback){
-      callback = options;
-      options = {};
-    }
-    if(!options) options = {};
-    if(!callback) callback = () => {};
-    return shell.exec(command, {
-      ...options,
-    }, callback);
-  }
+	exec.background = function execAsync(command, options, callback) {
+		if (typeof options == 'function' && !callback) {
+			callback = options;
+			options = {};
+		}
+		if (!options) options = {};
+		if (!callback) callback = () => {};
+		return shell.exec(
+			command,
+			{
+				...options,
+			},
+			callback,
+		);
+	};
 
-  function spawn(command, options){
-    return shell.spawn(command, options);
-  }
+	function spawn(command, options) {
+		return shell.spawn(command, options);
+	}
 
-  return { exec, spawn };
-}
+	return { exec, spawn };
+};

package/lib/rew/functions/export.js

@@ -1,27 +1,25 @@
-
-function exportsThe(item, name, context){
-  if (name) {
-    if(!context.module.exports) context.module.exports = {};
-    context.module.exports[name] = item;
-  } else {
-    if(context.module.exports) context.module.exports.default = item;
-    else context.module.exports = item;
-  }
+function exportsThe(item, name, context) {
+	if (name) {
+		if (!context.module.exports) context.module.exports = {};
+		context.module.exports[name] = item;
+	} else {
+		if (context.module.exports) context.module.exports.default = item;
+		else context.module.exports = item;
+	}
 }
 
 module.exports.pubFunction = function (context) {
-  return function (name, item) {
-    if(name && !item){
-      item = name;
-      name = null;
-    }
-    exportsThe(item, name, context);
-  };
+	return function (name, item) {
+		if (name && !item) {
+			item = name;
+			name = null;
+		}
+		exportsThe(item, name, context);
+	};
 };
 
 module.exports.exportsFunction = function (context) {
-  return function (item, name) {
-    exportsThe(item, name, context);
-  };
+	return function (item, name) {
+		exportsThe(item, name, context);
+	};
 };
-

package/lib/rew/functions/fs.js

@@ -2,58 +2,59 @@ const fs = require('fs');
 const path = require('path');
 const { execOptions } = require('../const/opt');
 
-
 module.exports = (currentFile) => {
-
-  function gp(filepath){
-    return path.resolve(filepath.startsWith(execOptions.cwdAlias) ? process.cwd() : path.dirname(currentFile), filepath.replaceAll(execOptions.cwdAlias+'/', ''));
-  }
-
-  function read(filepath, options = { encoding: 'utf-8' }){
-    return fs.readFileSync(gp(filepath), options);
-  }
-
-  function realpath(filepath, options = { encoding: 'utf-8' }){
-    return gp(filepath);
-  }
-
-  function write(filepath, content, options){
-    return fs.writeFileSync(gp(filepath), content, options);
-  }
-
-  function exists(filepath, options){
-    return fs.existsSync(gp(filepath));
-  }
-
-  function fstat(filepath, options){
-    return fs.statSync(gp(filepath), options);
-  }
-
-  function rm(filepath, options){
-    return fs.unlinkSync(filepath);
-  }
-
-  function chmod(filepath, mode, options){
-    return fs.chmodSync(gp(filepath), mode);
-  }
-
-  function mkdir(filepath, options){
-    return fs.mkdirSync(gp(filepath), options);
-  }
-
-  function ls(filepath, options){
-    return fs.readdirSync(gp(filepath), options);
-  }
-
-  return {
-    ls,
-    mkdir,
-    chmod,
-    rm,
-    fstat,
-    exists,
-    write,
-    read,
-    realpath
-  };
-} 
+	function gp(filepath) {
+		return path.resolve(
+			filepath.startsWith(execOptions.cwdAlias) ? process.cwd() : path.dirname(currentFile),
+			filepath.replaceAll(execOptions.cwdAlias + '/', ''),
+		);
+	}
+
+	function read(filepath, options = { encoding: 'utf-8' }) {
+		return fs.readFileSync(gp(filepath), options);
+	}
+
+	function realpath(filepath, options = { encoding: 'utf-8' }) {
+		return gp(filepath);
+	}
+
+	function write(filepath, content, options) {
+		return fs.writeFileSync(gp(filepath), content, options);
+	}
+
+	function exists(filepath, options) {
+		return fs.existsSync(gp(filepath));
+	}
+
+	function fstat(filepath, options) {
+		return fs.statSync(gp(filepath), options);
+	}
+
+	function rm(filepath, options) {
+		return fs.unlinkSync(filepath);
+	}
+
+	function chmod(filepath, mode, options) {
+		return fs.chmodSync(gp(filepath), mode);
+	}
+
+	function mkdir(filepath, options) {
+		return fs.mkdirSync(gp(filepath), options);
+	}
+
+	function ls(filepath, options) {
+		return fs.readdirSync(gp(filepath), options);
+	}
+
+	return {
+		ls,
+		mkdir,
+		chmod,
+		rm,
+		fstat,
+		exists,
+		write,
+		read,
+		realpath,
+	};
+};

package/lib/rew/functions/future.js

@@ -1,23 +1,31 @@
-const emitter = require("./emitter");
+const emitter = require('./emitter');
 
-module.exports = function future(callback, timeout = 0, defData = null) {
-  const listener = emitter();
-  const promise = new Promise((resolve, reject) => {
-    listener.on("resolve", (data) => {
-      resolve(data);
-    });
-    listener.on("reject", (data) => {
-      reject(data);
-    });
-    callback(resolve, reject);
-    if (timeout) setTimeout(() => resolve(defData), timeout);
-  });
-  return {
-    pipe: (callback) => promise.then(callback),
-    last: (callback) => promise.finally(callback),
-    catch: (callback) => promise.catch(callback),
-    resolve: (data) => listener.emit("resolve", data),
-    reject: (data) => listener.emit("reject", data),
-    wait: async () => await promise 
-  };
+function future(callback, timeout = 0, defData = null) {
+	const listener = emitter();
+	const promise = new Promise((resolve, reject) => {
+		listener.on('resolve', (data) => {
+			resolve(data);
+		});
+		listener.on('reject', (data) => {
+			reject(data);
+		});
+		callback(resolve, reject);
+		if (timeout) setTimeout(() => resolve(defData), timeout);
+	});
+	return {
+		pipe: (callback) => promise.then(callback),
+		last: (callback) => promise.finally(callback),
+		catch: (callback) => promise.catch(callback),
+		resolve: (data) => listener.emit('resolve', data),
+		reject: (data) => listener.emit('reject', data),
+		wait: async () => await promise,
+	};
 };
+
+future.promise = (promse, timeout = 0, defData = null) => {
+  return future((resolve, reject) => {
+    promse.then(resolve).catch(reject);
+  }, timeout, defData);
+}
+
+module.exports = future;

package/lib/rew/functions/id.js

@@ -1,13 +1,12 @@
 module.exports.generateRandomID = function generateRandomID(length = 12) {
-  const characters =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const charactersLength = characters.length;
-  let randomID = "";
+	const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+	const charactersLength = characters.length;
+	let randomID = '';
 
-  for (let i = 0; i < length; i++) {
-    const randomIndex = Math.floor(Math.random() * charactersLength);
-    randomID += characters.charAt(randomIndex);
-  }
+	for (let i = 0; i < length; i++) {
+		const randomIndex = Math.floor(Math.random() * charactersLength);
+		randomID += characters.charAt(randomIndex);
+	}
 
-  return randomID;
+	return randomID;
 };