@makano/rew 1.0.1

package/lib/rew/cli/utils.js

@@ -0,0 +1,122 @@
+const path = require('path');
+const fs = require('fs');
+const conf = require('../pkgs/conf');
+const jsYaml = require('js-yaml');
+const readline = require('readline');
+const { log, logget } = require('./log');
+const { execSync } = require('child_process');
+const { run } = require('../main');
+
+const npm_package_name = '@kevinj045/rew';
+
+module.exports = {
+  conf(command, fullPath, key, value){
+    const con = conf({});
+    if(command == 'get'){
+      if(!fullPath || fullPath == 'list'){
+        return fs.readdirSync(con.CONFIG_PATH).join('\n');
+      } else {
+        const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
+        const dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
+        const root = con.create(name);
+        if(dpath){
+          const fp = path.join(root.root, dpath);
+          if(fs.existsSync(fp) && fs.statSync(fp).isDirectory()){
+            return fs.readdirSync(fp).join('\n');
+          } else {
+            const o = con.create(name).optionCenter(dpath);
+            return key ? o.get(key) : o.getAll(true);
+          }
+        } else {
+          return fs.readdirSync(root.root).join('\n');
+        }
+      }
+    } else {
+      const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
+      const dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
+      if(name && key){
+        const root = con.create(name);
+        const o = dpath ? root.optionCenter(dpath) : root;
+        if(command == 'set') {
+          if(value){
+            o.set(key, value);
+          } else {
+            log('Value not specified', ':end');
+          }
+        } else {
+          o.remove(key);
+        }
+      } else {
+        log(
+          !name ? 'Path not specified' : 'Key not specified', ':end'
+        );
+      }
+    }
+  },
+  createProject: (ppath) => {
+    const projectPath = path.join(process.cwd(), ppath);
+    log('Crating at', ppath);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });    
+    const project = {};
+    const create = () => {
+      fs.mkdirSync(projectPath, { recursive: true });
+      const confPath = path.join(projectPath, 'app.yaml');
+      const entryFile = path.join(projectPath, 'main.coffee');
+      fs.writeFileSync(confPath, jsYaml.dump({ package: project.package, entry: 'main.coffee' }));
+      fs.writeFileSync(entryFile, `print("Hello World!")`);
+      if(project.git) {
+        execSync('cd '+projectPath+' && git init .');
+      }
+      log('Installing '+npm_package_name);
+      exec('cd '+projectPath+' && npm i '+npm_package_name, (err) => {
+        if(err){
+          console.error(err);
+          process.exit(0);
+        } else {
+          rl.close();
+        }
+      });
+    }
+    if (!fs.existsSync(projectPath)) {
+      rl.question(logget('Package Name: '), (pkg) => {
+        if(pkg.trim()) {
+          project.package = pkg.trim();
+          rl.question(logget('Use git(y/N): '), (use_git) => {
+            project.git = use_git.toLowerCase() == 'y' || use_git.toLowerCase() == 'yes';
+            create();
+          });
+        } else {
+          rl.close();
+        }
+      });
+    } else {
+      log(`Project ${ppath} already exists at ${projectPath}`, ':end');
+      rl.close();
+    }
+  },
+  runApp(pathOrPackage){
+    const apppath = path.resolve(process.cwd(), pathOrPackage);
+    const appConfpath = path.join(apppath, 'app.yaml');
+
+    const runAppRoot = (root, confPath) => {
+      const c = jsYaml.load(fs.readFileSync(confPath, { encoding: 'utf-8' }));
+      if(c.entry){
+        run(path.resolve(root, c.entry));
+      }
+    }
+
+    if(fs.existsSync(apppath) && fs.existsSync(appConfpath)){
+      runAppRoot(apppath, appConfpath);
+    } else {
+      const con = conf({});
+      const apppath = path.resolve(con.CONFIG_PATH, pathOrPackage, '$app');
+      const appConfpath = path.join(apppath, 'app.yaml');
+      if(fs.existsSync(apppath) && fs.existsSync(appConfpath)){
+        runAppRoot(apppath, appConfpath);
+      }
+    }
+  }
+}

package/lib/rew/const/default.js

@@ -0,0 +1,35 @@
+const { cenum } = require("../models/enum");
+const { struct } = require("../models/struct");
+const emitter = require("../functions/emitter");
+const future = require("../functions/future");
+const sleep = require("../functions/sleep");
+const { match } = require("../functions/match");
+const { map } = require("../functions/map");
+const { typex, typeis, typedef, typei } = require("../functions/types");
+const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry } = require("../functions/core");
+
+module.exports = {
+  cenum,
+  struct,
+  future,
+  emitter,
+  sleep,
+  match,
+  map,
+  typex,
+  typei,
+  typeis,
+  typedef,
+
+  isEmpty,
+  clone,
+  deepClone,
+  merge,
+  uniqueId,
+  compose,
+  curry,
+
+  print: function (...arguments) {
+    return console.log(...arguments);
+  },
+};

package/lib/rew/const/files.js

@@ -0,0 +1,15 @@
+const fs = require('fs');
+const path = require('path');
+
+const HOME_PATH = path.resolve(process.env.HOME, '.config/rew/default');
+const THEME_PATH = module.exports.THEME_PATH = path.resolve(HOME_PATH, 'theme.css');
+
+module.exports.FILES = [
+  {
+    path: HOME_PATH
+  },
+  {
+    path: THEME_PATH,
+    content: fs.readFileSync(path.resolve(__dirname, '../css/theme.css'))
+  }
+]

package/lib/rew/css/theme.css

@@ -0,0 +1,3 @@
+body {
+  background-color: #1c2541;
+}

package/lib/rew/functions/core.js

@@ -0,0 +1,85 @@
+
+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;
+  }
+}
+
+function clone(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;
+  }
+}
+
+function merge(obj1, obj2) {
+  return Object.assign({}, obj1, obj2);
+}
+
+const uniqueId = (() => {
+  let id = 0;
+  return () => {
+    id += 1;
+    return `id-${id}`;
+  };
+})();
+
+function filter(arr, fn) {
+  return arr.filter(fn);
+}
+
+function reduce(arr, fn, initial) {
+  return arr.reduce(fn, initial);
+}
+
+function compose(...fns) {
+  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;
+}
+
+module.exports = {
+  isEmpty,
+  clone,
+  deepClone,
+  merge,
+  uniqueId,
+  filter,
+  reduce,
+  compose,
+  curry
+};

package/lib/rew/functions/emitter.js

@@ -0,0 +1,57 @@
+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;
+};

package/lib/rew/functions/export.js

@@ -0,0 +1,9 @@
+module.exports.exportsFunction = function (context) {
+  return function (item, name) {
+    if (name) {
+      context.module.exports[name] = item;
+    } else {
+      context.module.exports = item;
+    }
+  };
+};

package/lib/rew/functions/future.js

@@ -0,0 +1,22 @@
+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),
+    pipex: (callback) => promise.finally(callback),
+    catch: (callback) => promise.catch(callback),
+    resolve: (data) => listener.emit("resolve", data),
+    reject: (data) => listener.emit("reject", data),
+  };
+};

package/lib/rew/functions/id.js

@@ -0,0 +1,13 @@
+module.exports.generateRandomID = function generateRandomID(length = 12) {
+  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);
+  }
+
+  return randomID;
+};

package/lib/rew/functions/import.js

@@ -0,0 +1,57 @@
+const path = require("path");
+const { getFile, file } = require("../modules/fs");
+const { importYaml } = require("../modules/yaml");
+const { findPackage, getPackage } = require("../pkgs/pkgs");
+
+module.exports.imp = function (runPath, context) {
+  return function (filename, options = {}) {
+    let type = options.type || "coffee";
+    let exports,
+      ispkg = findPackage(filename);
+
+    const filepath = path.resolve(path.dirname(context.module.filepath), filename);
+
+    // console.log(typeof runPath);
+
+    if (ispkg) {
+      exports = getPackage(filename)(context);
+    } else if (type == "coffee") {
+      exports = runPath(
+        filepath,
+        { ...options, useContext: true },
+        context,
+      ).context.module.exports;
+    } else if (type == "js") {
+      exports = runPath(
+        filepath,
+        { ...options, useContext: true, compile: false },
+        context,
+      ).context.module.exports;
+    } else if (type == "yaml" || type == "json" || type == "text") {
+      const f = getFile(filepath);
+      if (type == "yaml") {
+        exports = importYaml(f.path, f);
+      } else if (type == "json") {
+        try {
+          exports = JSON.parse(f.content);
+        } catch (e) {
+          exports = {};
+        }
+      } else {
+        exports = f.content;
+      }
+    }
+
+    if (options.save && (type == "js" || type == "coffee")) {
+      if (typeof options.save == "string") context[options.save] = exports[i];
+      else
+        for (let i in exports) {
+          context[i] = exports[i];
+        }
+    }
+
+    if(!ispkg) context.module.imports.push(filepath);
+
+    return exports;
+  };
+};

package/lib/rew/functions/map.js

@@ -0,0 +1,17 @@
+
+
+
+module.exports.map = function map(...args) {
+  if (args.length % 2 !== 0) {
+    throw new Error('Arguments must be in key-value pairs');
+  }
+
+  const result = new Map();
+  for (let i = 0; i < args.length; i += 2) {
+    const key = args[i];
+    const value = args[i + 1];
+    result.set(key, value);
+  }
+
+  return result;
+};

package/lib/rew/functions/match.js

@@ -0,0 +1,34 @@
+
+const SerializableData = ["string", "number", "boolean"];
+
+const isRegExp = (obj) => Object.prototype.toString.call(obj) === '[object RegExp]';
+
+module.exports.match = function match(value, templates, props) {
+  const matchProps = (pattern, value) => {
+    if (!props) return false;
+    if (typeof props === "object") {
+      let t = true;
+      for (let i in props) {
+        t = t && pattern[i] == value[i];
+        if (!t) break;
+      }
+      return t;
+    } else if (typeof props === "function") {
+      return props(pattern, value);
+    } else {
+      return false;
+    }
+  };
+
+  const matchRegex = (pattern, value) => pattern.test(value);
+
+  const entries = templates instanceof Map ? templates.entries() : Array.isArray(templates) ? templates : Object.entries(templates);
+
+  for (const [pattern, callback] of entries) {
+    if (isRegExp(pattern) ? matchRegex(pattern, value) : SerializableData.includes(typeof value) ? pattern == value : (isRegExp(pattern) ? matchRegex(pattern, value) : (typeof pattern === "function" ? value instanceof pattern || value?.__proto__?.['@instance'] === pattern : matchProps(pattern, value)))) {
+      return callback(...(isRegExp(pattern) ? pattern.exec(value) : [value]));
+    }
+  }
+
+  return null;
+};

package/lib/rew/functions/sleep.js

@@ -0,0 +1,5 @@
+const future = require("./future");
+
+module.exports = async function sleep(time) {
+  return new Promise((r) => setTimeout(r, time));
+};

package/lib/rew/functions/types.js

@@ -0,0 +1,96 @@
+
+const _defaultConstructors = {
+  string: String,
+  array: Array,
+  number: Number,
+  bigint: BigInt,
+  boolean: Boolean,
+  symbol: Symbol,
+  undefined: Object,
+  object: Object,
+  function: Function
+}
+
+function getType(value){
+  return typeof value === 'object' ? Array.isArray(value) ? 'array' : typeof value : typeof value;
+}
+
+function typedef(value) {
+  return {
+    defaultValue: value,
+    class: typeof value == 'function' ? value : typeof value === 'object' && value !== null && !Array.isArray(value) ? value.constructor : _defaultConstructors[getType(value)],
+    type: getType(value),
+    isConstucted: typeof value === 'object' && value !== null && !Array.isArray(value),
+    isEmpty: typeof value == "object" ? !Object.keys(value).length : typeof value == "string" ? value == "" : true
+  };
+}
+
+function typeis(obj, typeDef) {
+  if (typeDef.isConstucted && typeDef.class && !(obj instanceof typeDef.class)) {
+    return false;
+  }
+
+  if(getType(obj) == "object" && typeDef.type == 'function') {
+    return (obj instanceof typeDef.class);
+  }
+
+  if(getType(obj) !== typeDef.type){
+    return false;
+  }
+
+  if(!typeDef.isEmpty) {
+    if(typeDef.type == 'object'){
+      for (const key in typeDef.defaultValue) {
+        const propTypeDef = typeDef.defaultValue[key];
+    
+        if (typeof propTypeDef === 'object') {
+          if (!typeis(obj[key], propTypeDef)) {
+            return false;
+          }
+        } else if (typeof obj[key] !== propTypeDef) {
+          return false;
+        }
+      }
+    } else if(typeDef.type == 'string'){
+      return typeDef.defaultValue == obj;
+    }
+  }
+
+  return true;
+}
+
+function typex(child, parent) {
+  return child.prototype instanceof parent || child === parent;
+}
+
+function typei(child, parent) {
+  return child instanceof parent || child.constructor === parent;
+}
+
+module.exports = {
+  typex,
+  typei,
+  typeis,
+  typedef
+}
+
+
+// const f = typedef('');
+// const fg = typedef({ g: f });
+
+// const g = { g: 'sss' };
+
+// class L {}
+
+// class N {}
+
+// class M extends N{}
+
+// let n = new N
+// let m = new M
+// let l = new L
+
+// let tn = typedef(n)
+
+// // console.log(typeis(g, fg), typeis(1, f), typei('', String));
+// console.log(typeis(l, tn));