@makano/rew 1.1.73 → 1.1.81

package/lib/rew/modules/context.js

@@ -1,39 +1,40 @@
 const defaultContext = require("../const/default");
 const { execOptions } = require("../const/opt");
-const emitter = require("../functions/emitter");
 const { exportsFunction, pubFunction } = require("../functions/export");
 const { imp } = require("../functions/import");
 const { customRequire } = require("../functions/require");
-const fsLib = require('../functions/fs');
-const pathLib = require('../functions/path');
-const execLib = require('../functions/exec');
+const fsLib = require("../functions/fs");
+const pathLib = require("../functions/path");
+const execLib = require("../functions/exec");
+const { findAppInfo } = require("../misc/findAppInfo");
 
 let mainFile = "";
-const isMainFile = filepath => filepath == mainFile;
+const isMainFile = (filepath) => filepath == mainFile;
 module.exports.prepareContext = function (
   custom_context,
   options,
   filepath = "",
   runPath = () => {},
 ) {
-  if(mainFile == "") mainFile = filepath;
+  if (mainFile == "") mainFile = filepath;
   let context = {
     module: {
       exports: null,
       filepath,
       main: isMainFile(filepath),
-      imports: []
+      imports: [],
     },
     imports: {
       meta: {},
-      assert: options.import ?? {}
+      assert: options.import ?? {},
     },
+    app: findAppInfo(filepath),
     ...fsLib(filepath),
   };
   if (options.useContext) {
     context = {
       ...custom_context,
-      ...context
+      ...context,
     };
   } else {
     context = {
@@ -43,9 +44,15 @@ module.exports.prepareContext = function (
       ...execLib(filepath),
       require: (package) => {
         try {
-          return execOptions.nativeRequire || package.startsWith('node:') ? require(package.startsWith('node:') ? package.split('node:')[1] : package) : customRequire(package, filepath);
+          return execOptions.nativeRequire || package.startsWith("node:")
+            ? require(
+                package.startsWith("node:")
+                  ? package.split("node:")[1]
+                  : package,
+              )
+            : customRequire(package, filepath);
         } catch (e) {
-          throw new Error("Module "+package+" not found");
+          throw new Error("Module " + package + " not found");
         }
       },
       ...custom_context,
@@ -57,34 +64,40 @@ module.exports.prepareContext = function (
       target: {
         on: (event, listener) => process.on(event, listener),
         off: (event, listener) => process.off(event, listener),
-        emit: (event, code) => process.emit(event, code)
+        emit: (event, code) => process.emit(event, code),
       },
       env: process.env,
       cwd: () => process.cwd(),
-      arch: process.arch
+      arch: process.arch,
     };
-  
+
   context.global = context;
   context.imports.assert = options.import ?? {};
   context.imp = imp(runPath, context);
   context.inc = (package, asserts) => {
-    try{
-      if(package.startsWith('node:') || package.startsWith('pkg:')) throw new Error('');
+    try {
+      if (package.startsWith("node:") || package.startsWith("pkg:"))
+        throw new Error("");
       return context.imp(package, asserts);
-    } catch(e) {
-      return context.require(package.startsWith('pkg:') ? package.split('pkg:')[1] : package);
+    } catch (e) {
+      return context.require(
+        package.startsWith("pkg:") ? package.split("pkg:")[1] : package,
+      );
     }
   };
   context.pub = pubFunction(context);
   context.exports = exportsFunction(context);
 
-  if(context.module.main || (options.fromMain == true && options.as == 'main')){
+  if (
+    context.module.main ||
+    (options.fromMain == true && options.as == "main")
+  ) {
     context.opt = {
-      set: (key, value) => execOptions[key] = value,
+      set: (key, value) => (execOptions[key] = value),
       get: (key) => execOptions[key],
       push: (key, value) => execOptions[key]?.push(value),
-      pop: (key) => execOptions[key]?.pop()
+      pop: (key) => execOptions[key]?.pop(),
     };
-  } else delete context.opt
+  } else delete context.opt;
   return context;
 };

package/lib/rew/modules/runtime.js

@@ -6,7 +6,7 @@ const exec = (module.exports.exec = function (code, context) {
   return vm.runInNewContext(code, vm.createContext(context), {
     filename: context.module.filepath,
     lineOffset: 0,
-    displayErrors: true
+    displayErrors: true,
   });
 });
 

package/lib/rew/pkgs/conf.js

@@ -1,83 +1,100 @@
-const fs = require('fs');
-const jsYaml = require('js-yaml');
-const path = require('path');
-
-const CONFIG_PATH = path.resolve(process.env.HOME, '.config/rew');
+const fs = require("fs");
+const jsYaml = require("js-yaml");
+const path = require("path");
+const { CONFIG_PATH } = require("../const/config_path");
+const { seededID } = require("../misc/seededid");
 
 const createPackageRoot = (packageName) => {
   const rootPath = path.join(CONFIG_PATH, packageName);
   fs.mkdirSync(rootPath, { recursive: true });
   return rootPath;
-}
+};
 
 module.exports = (context) => ({
   CONFIG_PATH,
+  _onImport() {
+    if (context.app) {
+      return this.create(context.app.config.package);
+    } else {
+      return this.create(
+        seededID(
+          path.basename(context.module.filepath).replace(/[-_/\.]/g, ""),
+        ),
+      );
+    }
+  },
   create: (packageName) => {
     const rootPath = createPackageRoot(packageName);
 
     const conf = {};
 
     const dumpYaml = (val) => {
-      if(JSON.stringify(val) == '{}') return '';
+      if (JSON.stringify(val) == "{}") return "";
       else return jsYaml.dump(val);
-    }
+    };
 
     const setData = (optionCenter, key, value) => {
       conf[optionCenter.name][key] = value;
       fs.writeFileSync(optionCenter.root, dumpYaml(conf[optionCenter.name]));
       return true;
-    }
+    };
 
     const removeData = (optionCenter, key) => {
       delete conf[optionCenter.name][key];
       fs.writeFileSync(optionCenter.root, dumpYaml(conf[optionCenter.name]));
       return true;
-    }
+    };
 
     const getData = (optionCenter, key) => {
       return conf[optionCenter.name][key];
-    }
+    };
 
     const staticFile = (name, defaultValue = "") => {
       const fileRoot = path.join(rootPath, name);
       const exists = fs.existsSync(fileRoot);
       return {
-        create(value){
-          if(!fs.existsSync(path.dirname(fileRoot))) fs.mkdirSync(path.dirname(fileRoot), { recursive: true }); 
+        create(value) {
+          if (!fs.existsSync(path.dirname(fileRoot)))
+            fs.mkdirSync(path.dirname(fileRoot), { recursive: true });
           fs.writeFileSync(fileRoot, value || defaultValue);
         },
         fileRoot,
-        exists
-      }
-    }
-    
+        exists,
+      };
+    };
+
     const createOptionCenter = (name, defaults = {}) => {
-      const optionRoot = path.join(rootPath, name+'.yaml');
-      if(!fs.existsSync(path.dirname(optionRoot))) fs.mkdirSync(path.dirname(optionRoot), { recursive: true }); 
-      if(!fs.existsSync(optionRoot)) {
+      const optionRoot = path.join(rootPath, name + ".yaml");
+      if (!fs.existsSync(path.dirname(optionRoot)))
+        fs.mkdirSync(path.dirname(optionRoot), { recursive: true });
+      if (!fs.existsSync(optionRoot)) {
         conf[name] = defaults;
         fs.writeFileSync(optionRoot, dumpYaml(defaults));
       } else {
-        conf[name] = jsYaml.load(fs.readFileSync(optionRoot, { encoding: 'utf-8' }));
+        conf[name] = jsYaml.load(
+          fs.readFileSync(optionRoot, { encoding: "utf-8" }),
+        );
       }
 
       const optionCenter = {
         root: optionRoot,
         name,
-        package: packageName
-      }
+        package: packageName,
+      };
 
       return {
         get: (key) => getData(optionCenter, key),
         set: (key, value) => setData(optionCenter, key, value),
         remove: (key) => removeData(optionCenter, key),
-        reset: () => fs.writeFileSync(optionCenter.root, dumpYaml(defaults)) && (conf[name] = defaults),
-        getAll: (str = false) => str ? dumpYaml(conf[name]) : conf[name],
-        ...optionCenter
-      }
-    }
+        reset: () =>
+          fs.writeFileSync(optionCenter.root, dumpYaml(defaults)) &&
+          (conf[name] = defaults),
+        getAll: (str = false) => (str ? dumpYaml(conf[name]) : conf[name]),
+        ...optionCenter,
+      };
+    };
 
-    const defaultCenter = createOptionCenter('_default', { default: true });
+    const defaultCenter = createOptionCenter("_default", { default: true });
 
     return {
       optionCenter: createOptionCenter,
@@ -86,7 +103,7 @@ module.exports = (context) => ({
       get: (key) => defaultCenter.get(key),
       remove: (key) => defaultCenter.remove(key),
       root: rootPath,
-      package: packageName
-    }
-  }
-});
+      package: packageName,
+    };
+  },
+});

package/lib/rew/pkgs/data.js

@@ -4,5 +4,10 @@ const { LinkedList } = require("./modules/data/linkedList");
 const { Queue } = require("./modules/data/queue");
 const { Stack } = require("./modules/data/stack");
 
-
-module.exports = (context) => ({ Stack, Queue, BinaryTree, DoublyLinkedList, LinkedList });
+module.exports = (context) => ({
+  Stack,
+  Queue,
+  BinaryTree,
+  DoublyLinkedList,
+  LinkedList,
+});

package/lib/rew/pkgs/date.js

@@ -9,8 +9,8 @@
  */
 function formatDate(date) {
   const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
 
@@ -20,9 +20,9 @@ function formatDate(date) {
  * @return {string} - The formatted time string.
  */
 function formatTime(date) {
-  const hours = String(date.getHours()).padStart(2, '0');
-  const minutes = String(date.getMinutes()).padStart(2, '0');
-  const seconds = String(date.getSeconds()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
   return `${hours}:${minutes}:${seconds}`;
 }
 
@@ -34,7 +34,7 @@ function formatTime(date) {
  * @return {Date} - The parsed date object.
  */
 function parseDate(dateString) {
-  const [year, month, day] = dateString.split('-').map(Number);
+  const [year, month, day] = dateString.split("-").map(Number);
   return new Date(year, month - 1, day);
 }
 
@@ -44,7 +44,7 @@ function parseDate(dateString) {
  * @return {Date} - The parsed date object.
  */
 function parseTime(timeString) {
-  const [hours, minutes, seconds] = timeString.split(':').map(Number);
+  const [hours, minutes, seconds] = timeString.split(":").map(Number);
   const date = new Date();
   date.setHours(hours, minutes, seconds, 0);
   return date;
@@ -85,7 +85,6 @@ function differenceInDays(date1, date2) {
   return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
 }
 
-
 // Exporting the functions as a CommonJS module
 module.exports = () => ({
   formatDate,
@@ -94,5 +93,5 @@ module.exports = () => ({
   parseTime,
   addDays,
   subtractDays,
-  differenceInDays
+  differenceInDays,
 });

package/lib/rew/pkgs/env.js

@@ -1,9 +1,7 @@
-
-
 module.exports = (context) => ({
   has: (key) => key in process.env,
   get: (key) => process.env[key],
-  set: (key, value) => process.env[key] = value,
+  set: (key, value) => (process.env[key] = value),
   rm: (key) => delete process.env[key],
-  is: (key, value) => process.env[key] == value
-})
+  is: (key, value) => process.env[key] == value,
+});

package/lib/rew/pkgs/modules/data/bintree.js

@@ -63,4 +63,4 @@ class BinaryTree {
 
 BinaryTree.Node = TreeNode;
 
-module.exports = { BinaryTree };
+module.exports = { BinaryTree };

package/lib/rew/pkgs/modules/data/doublylinked.js

@@ -97,4 +97,4 @@ class DoublyLinkedList {
 
 DoublyLinkedList.Node = DoublyNode;
 
-module.exports = { DoublyLinkedList };
+module.exports = { DoublyLinkedList };

package/lib/rew/pkgs/modules/data/linkedList.js

@@ -85,4 +85,4 @@ class LinkedList {
 
 LinkedList.Node = Node;
 
-module.exports = { LinkedList };
+module.exports = { LinkedList };

package/lib/rew/pkgs/modules/data/queue.js

@@ -24,5 +24,4 @@ class Queue {
   }
 }
 
-
-module.exports = { Queue };
+module.exports = { Queue };

package/lib/rew/pkgs/modules/data/stack.js

@@ -24,4 +24,4 @@ class Stack {
   }
 }
 
-module.exports = { Stack };
+module.exports = { Stack };

package/lib/rew/pkgs/modules/threads/worker.js

@@ -1,36 +1,46 @@
-const { parentPort, workerData } = require('worker_threads');
-const { exec } = require('../../../modules/runtime');
+const { parentPort, workerData } = require("worker_threads");
+const { exec } = require("../../../modules/runtime");
 
 const target = {};
 target.events = [];
 target.on = (e, cb) => {
   target.events.push({ e, cb });
-}
+};
 target.off = (e) => {
-  target.events = target.events.filter(i => i.e !== e);
-}
+  target.events = target.events.filter((i) => i.e !== e);
+};
 target.emit = (e, data) => {
-  target.events.filter(i => i.e == e).forEach(i => i.cb(data));
-}
+  target.events.filter((i) => i.e == e).forEach((i) => i.cb(data));
+};
 
-parentPort.on('message', (data) => {
-  if (data.type === 'event') {
+parentPort.on("message", (data) => {
+  if (data.type === "event") {
     target.emit(data.event, data.data);
-  } else if (data.type === 'start') {
+  } else if (data.type === "start") {
     (async () => {
       try {
-        exec(`(${workerData.cb}).call({ process }, context)`, { print: (...a) => console.log(...a), process: {
-          on: (e, cb) => { target.on(e, cb) },
-          off: (e) => { target.off(e) },
-          emit: (e, data) => { parentPort.postMessage({ type: 'event', event: e, data }) },
-          exit: (code) => process.exit(code),
-          finish: (data) => {
-            parentPort.postMessage({ type: 'result', result: data });
-            process.exit(0)
-          }
-        }, context: workerData.context })
+        exec(`(${workerData.cb}).call({ process }, context)`, {
+          print: (...a) => console.log(...a),
+          process: {
+            on: (e, cb) => {
+              target.on(e, cb);
+            },
+            off: (e) => {
+              target.off(e);
+            },
+            emit: (e, data) => {
+              parentPort.postMessage({ type: "event", event: e, data });
+            },
+            exit: (code) => process.exit(code),
+            finish: (data) => {
+              parentPort.postMessage({ type: "result", result: data });
+              process.exit(0);
+            },
+          },
+          context: workerData.context,
+        });
       } catch (e) {
-        parentPort.postMessage({ type: 'error', error: e.message });
+        parentPort.postMessage({ type: "error", error: e.message });
       }
     })();
   }