@makano/rew 1.1.72 → 1.1.81

package/lib/rew/cli/utils.js

@@ -1,76 +1,82 @@
-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, exec } = require('child_process');
-const { run } = require('../main');
-const { generateRandomID } = require('../functions/id');
+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, exec } = require("child_process");
+const { run } = require("../main");
+const { generateRandomID } = require("../functions/id");
 
-const npm_package_name = '@makano/rew';
+const npm_package_name = "@makano/rew";
 
 module.exports = {
-  conf(command, fullPath, key, value){
+  conf(command, fullPath, key, value) {
     const con = conf({});
-    if(command == 'get'){
-      if(!fullPath || fullPath == 'list'){
-        return fs.readdirSync(con.CONFIG_PATH).join('\n');
+    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 name = fullPath.indexOf("/") ? fullPath.split("/")[0] : fullPath;
+        const dpath = fullPath.indexOf("/")
+          ? fullPath.split("/").slice(1).join("/")
+          : "";
         const root = con.create(name);
-        if(dpath){
+        if (dpath) {
           const fp = path.join(root.root, dpath);
-          if(fs.existsSync(fp) && fs.statSync(fp).isDirectory()){
-            return fs.readdirSync(fp).join('\n');
+          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');
+          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 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){
+        if (command == "set") {
+          if (value) {
             o.set(key, value);
           } else {
-            log('Value not specified', ':end');
+            log("Value not specified", ":end");
           }
         } else {
           o.remove(key);
         }
       } else {
-        log(
-          !name ? 'Path not specified' : 'Key not specified', ':end'
-        );
+        log(!name ? "Path not specified" : "Key not specified", ":end");
       }
     }
   },
   createProject: (ppath) => {
     const projectPath = path.join(process.cwd(), ppath);
-    log('Crating at', ppath);
+    log("Crating at", ppath);
     const rl = readline.createInterface({
       input: process.stdin,
-      output: process.stdout
-    });    
+      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' }));
+      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) {
-        fs.writeFileSync(path.join(projectPath, '.gitignore'), `node_modules/\npackage-lock.json`);
-        execSync('cd '+projectPath+' && git init .');
+      if (project.git) {
+        fs.writeFileSync(
+          path.join(projectPath, ".gitignore"),
+          `node_modules/\npackage-lock.json`,
+        );
+        execSync("cd " + projectPath + " && git init .");
       }
       // log('Installing '+npm_package_name);
       // exec('cd '+projectPath+' && npm i '+npm_package_name, (err) => {
@@ -81,15 +87,16 @@ module.exports = {
       //     rl.close();
       //   }
       // });
-      log('Done.', ':end');
+      log("Done.", ":end");
       rl.close();
-    }
+    };
     if (!fs.existsSync(projectPath)) {
-      rl.question(logget('Package Name: '), (pkg) => {
-        if(pkg.trim()) {
+      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';
+          rl.question(logget("Use git(y/N): "), (use_git) => {
+            project.git =
+              use_git.toLowerCase() == "y" || use_git.toLowerCase() == "yes";
             create();
           });
         } else {
@@ -97,96 +104,103 @@ module.exports = {
         }
       });
     } else {
-      log(`Project ${ppath} already exists at ${projectPath}`, ':end');
+      log(`Project ${ppath} already exists at ${projectPath}`, ":end");
       rl.close();
     }
   },
-  runApp(pathOrPackage){
+  runApp(pathOrPackage) {
     const apppath = path.resolve(process.cwd(), pathOrPackage);
-    const appConfpath = path.join(apppath, 'app.yaml');
+    const appConfpath = path.join(apppath, "app.yaml");
 
     const runAppRoot = (root, confPath) => {
-      const c = jsYaml.load(fs.readFileSync(confPath, { encoding: 'utf-8' }));
-      if(c.entry){
+      const c = jsYaml.load(fs.readFileSync(confPath, { encoding: "utf-8" }));
+      if (c.entry) {
         const r = path.resolve(root, c.entry);
-        const mod_path = path.resolve(root, 'snode_moduless/@makano/rew');
-        const mod_path_lib = path.join(mod_path, 'lib/rew/cli');
-        if(fs.existsSync(mod_path) && __dirname !== mod_path_lib){
-          const mod_path_utilsjs = path.join(mod_path_lib, '../main.js');
-          require(mod_path_utilsjs)
-          .run(r);
+        const mod_path = path.resolve(root, "snode_moduless/@makano/rew");
+        const mod_path_lib = path.join(mod_path, "lib/rew/cli");
+        if (fs.existsSync(mod_path) && __dirname !== mod_path_lib) {
+          const mod_path_utilsjs = path.join(mod_path_lib, "../main.js");
+          require(mod_path_utilsjs).run(r);
         } else run(r);
       }
-    }
+    };
 
-    if(fs.existsSync(apppath) && fs.existsSync(appConfpath)){
+    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)){
+      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);
       }
     }
   },
-  installApp(pathname, rmidir, rmidiri){
-    if(!pathname){
+  installApp(pathname, rmidir, rmidiri) {
+    if (!pathname) {
       return;
     }
     const apppath = path.resolve(process.cwd(), pathname);
-    const appConfpath = path.join(apppath, 'app.yaml');
-    const appPackagepath = path.join(apppath, 'package.json');
-    if(fs.existsSync(apppath) && fs.existsSync(appConfpath)){
-      const c = jsYaml.load(fs.readFileSync(appConfpath, { encoding: 'utf-8' }));
-      const p = JSON.parse(fs.readFileSync(appPackagepath, { encoding: 'utf-8' }));
+    const appConfpath = path.join(apppath, "app.yaml");
+    const appPackagepath = path.join(apppath, "package.json");
+    if (fs.existsSync(apppath) && fs.existsSync(appConfpath)) {
+      const c = jsYaml.load(
+        fs.readFileSync(appConfpath, { encoding: "utf-8" }),
+      );
+      const p = JSON.parse(
+        fs.readFileSync(appPackagepath, { encoding: "utf-8" }),
+      );
       const pname = c.package;
-      const installPath = path.join(conf({}).create(pname).root, 'app');
+      const installPath = path.join(conf({}).create(pname).root, "app");
       const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout
-      });    
-      log('Installing '+pname);
-      log("Package: "+p.name+'@'+p.version);
-      if(p.description){
-        log("Description: "+p.description);
+        output: process.stdout,
+      });
+      log("Installing " + pname);
+      log("Package: " + p.name + "@" + p.version);
+      if (p.description) {
+        log("Description: " + p.description);
       }
-      rl.question(logget('Install '+pname+'? (y/N)'), (f) => {
-        if(f.toLowerCase() == 'y'){
-          if(fs.existsSync(installPath)){
+      rl.question(logget("Install " + pname + "? (y/N)"), (f) => {
+        if (f.toLowerCase() == "y") {
+          if (fs.existsSync(installPath)) {
             execSync(`rm -r ${installPath}`);
           }
           execSync(`cp -r ${apppath} ${installPath}`);
-          if(rmidir){
+          if (rmidir) {
             execSync(`rm -r ${apppath}`);
           }
-          log('Installed '+pname, ':end');
+          log("Installed " + pname, ":end");
           rl.close();
         } else {
-          if(rmidiri){
+          if (rmidiri) {
             execSync(`rm -r ${apppath}`);
           }
-          log('Canceled install', ':end');
+          log("Canceled install", ":end");
           rl.close();
         }
       });
     } else {
-      log('Path is not a rew app', ':end');
+      log("Path is not a rew app", ":end");
     }
   },
-  async cloneGit(gitpath){
-    const p = gitpath.split('github:')[1];
+  async cloneGit(gitpath) {
+    const p = gitpath.split("github:")[1];
     const url = `https://github.com/${p}`;
     const apiurl = `https://api.github.com/repos/${p}`;
     return await fetch(apiurl)
-    .then((r) => {
-      if(r.status !== 200) return log('Repo not found', ':end');
-      const tempPath = '/tmp/rew-git-clone-'+p.replace(/\//g, '_')+'-'+generateRandomID();
-      execSync(`git clone ${url} ${tempPath}`);
-      console.log('Installing deps...');
-      execSync(`cd ${tempPath} && npm i`);
-      return tempPath;
-    })
-    .catch(r => null);
-  }
-}
+      .then((r) => {
+        if (r.status !== 200) return log("Repo not found", ":end");
+        const tempPath =
+          "/tmp/rew-git-clone-" +
+          p.replace(/\//g, "_") +
+          "-" +
+          generateRandomID();
+        execSync(`git clone ${url} ${tempPath}`);
+        console.log("Installing deps...");
+        execSync(`cd ${tempPath} && npm i`);
+        return tempPath;
+      })
+      .catch((r) => null);
+  },
+};

package/lib/rew/const/config_path.js

@@ -0,0 +1,4 @@
+const path = require("path");
+
+const CONFIG_PATH = path.resolve(process.env.HOME, ".config/rew");
+module.exports.CONFIG_PATH = CONFIG_PATH;

package/lib/rew/const/default.js

@@ -5,8 +5,26 @@ 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, int, float, num, str, bool } = require("../functions/types");
-const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry } = require("../functions/core");
+const {
+  typex,
+  typeis,
+  typedef,
+  typei,
+  int,
+  float,
+  num,
+  str,
+  bool,
+} = require("../functions/types");
+const {
+  isEmpty,
+  clone,
+  deepClone,
+  merge,
+  uniqueId,
+  compose,
+  curry,
+} = require("../functions/core");
 const { print, input } = require("../functions/stdout");
 
 module.exports = {
@@ -38,5 +56,5 @@ module.exports = {
   curry,
 
   print,
-  input
+  input,
 };

package/lib/rew/const/files.js

@@ -1,15 +1,18 @@
-const fs = require('fs');
-const path = require('path');
+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');
+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: HOME_PATH,
   },
   {
     path: THEME_PATH,
-    content: fs.readFileSync(path.resolve(__dirname, '../css/theme.css'))
-  }
-]
+    content: fs.readFileSync(path.resolve(__dirname, "../css/theme.css")),
+  },
+];

package/lib/rew/const/opt.js

@@ -1,10 +1,10 @@
 const execOptions = {
   sharedContext: true,
-  resolveExtensions: [{ext: '.js', options: { type: 'js' }}, '.coffee'],
+  resolveExtensions: [{ ext: ".js", options: { type: "js" } }, ".coffee"],
   nativeRequire: false,
-  cwdAlias: '$',
-  jsxPragma: 'createElement',
-  jsx: false
-}
+  cwdAlias: "$",
+  jsxPragma: "createElement",
+  jsx: false,
+};
 
-module.exports.execOptions = execOptions;
+module.exports.execOptions = execOptions;

package/lib/rew/css/theme.css

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

package/lib/rew/functions/core.js

@@ -1,9 +1,7 @@
-
-
 function isEmpty(value) {
-  if (Array.isArray(value) || typeof value === 'string') {
+  if (Array.isArray(value) || typeof value === "string") {
     return value.length === 0;
-  } else if (typeof value === 'object') {
+  } else if (typeof value === "object") {
     return Object.keys(value).length === 0;
   } else {
     return true;
@@ -13,7 +11,7 @@ function isEmpty(value) {
 function clone(value) {
   if (Array.isArray(value)) {
     return value.slice();
-  } else if (typeof value === 'object') {
+  } else if (typeof value === "object") {
     return Object.assign({}, value);
   } else {
     return value;
@@ -22,8 +20,8 @@ function clone(value) {
 
 function deepClone(value) {
   if (Array.isArray(value)) {
-    return value.map(item => deepClone(item));
-  } else if (typeof value === 'object') {
+    return value.map((item) => deepClone(item));
+  } else if (typeof value === "object") {
     const obj = {};
     for (const key in value) {
       if (value.hasOwnProperty(key)) {
@@ -57,7 +55,7 @@ function reduce(arr, fn, initial) {
 }
 
 function compose(...fns) {
-  return initialValue => {
+  return (initialValue) => {
     return fns.reduceRight((acc, fn) => fn(acc), initialValue);
   };
 }
@@ -82,5 +80,5 @@ module.exports = {
   filter,
   reduce,
   compose,
-  curry
+  curry,
 };

package/lib/rew/functions/emitter.js

@@ -11,11 +11,11 @@ module.exports = function emitter() {
   };
   const off = (event, callback, removable = null) => {
     const rm = (event) => {
-      if(removable){
+      if (removable) {
         removable(event);
       }
       events.splice(events.indexOf(event), 1);
-    }
+    };
     const rmEvent = (event) => {
       if (callback) {
         const _events = events.filter(({ callback: c }) => c == callback);

package/lib/rew/functions/exec.js

@@ -1,27 +1,31 @@
-const shell = require('child_process');
-
+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){
+  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);
-  }
+    if (!options) options = {};
+    if (!callback) callback = () => {};
+    return shell.exec(
+      command,
+      {
+        ...options,
+      },
+      callback,
+    );
+  };
 
-  function spawn(command, options){
+  function spawn(command, options) {
     return shell.spawn(command, options);
   }
 
   return { exec, spawn };
-}
+};

package/lib/rew/functions/export.js

@@ -1,17 +1,16 @@
-
-function exportsThe(item, name, context){
+function exportsThe(item, name, context) {
   if (name) {
-    if(!context.module.exports) context.module.exports = {};
+    if (!context.module.exports) context.module.exports = {};
     context.module.exports[name] = item;
   } else {
-    if(context.module.exports) context.module.exports.default = item;
+    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){
+    if (name && !item) {
       item = name;
       name = null;
     }
@@ -24,4 +23,3 @@ module.exports.exportsFunction = function (context) {
     exportsThe(item, name, context);
   };
 };
-

package/lib/rew/functions/fs.js

@@ -1,47 +1,50 @@
-const fs = require('fs');
-const path = require('path');
-const { execOptions } = require('../const/opt');
-
+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 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' }){
+  function read(filepath, options = { encoding: "utf-8" }) {
     return fs.readFileSync(gp(filepath), options);
   }
 
-  function realpath(filepath, options = { encoding: 'utf-8' }){
+  function realpath(filepath, options = { encoding: "utf-8" }) {
     return gp(filepath);
   }
 
-  function write(filepath, content, options){
+  function write(filepath, content, options) {
     return fs.writeFileSync(gp(filepath), content, options);
   }
 
-  function exists(filepath, options){
+  function exists(filepath, options) {
     return fs.existsSync(gp(filepath));
   }
 
-  function fstat(filepath, options){
+  function fstat(filepath, options) {
     return fs.statSync(gp(filepath), options);
   }
 
-  function rm(filepath, options){
+  function rm(filepath, options) {
     return fs.unlinkSync(filepath);
   }
 
-  function chmod(filepath, mode, options){
+  function chmod(filepath, mode, options) {
     return fs.chmodSync(gp(filepath), mode);
   }
 
-  function mkdir(filepath, options){
+  function mkdir(filepath, options) {
     return fs.mkdirSync(gp(filepath), options);
   }
 
-  function ls(filepath, options){
+  function ls(filepath, options) {
     return fs.readdirSync(gp(filepath), options);
   }
 
@@ -54,6 +57,6 @@ module.exports = (currentFile) => {
     exists,
     write,
     read,
-    realpath
+    realpath,
   };
-} 
+};

package/lib/rew/functions/future.js

@@ -18,6 +18,6 @@ module.exports = function future(callback, timeout = 0, defData = null) {
     catch: (callback) => promise.catch(callback),
     resolve: (data) => listener.emit("resolve", data),
     reject: (data) => listener.emit("reject", data),
-    wait: async () => await promise 
+    wait: async () => await promise,
   };
 };