@makano/rew 1.1.73 → 1.2.0

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/fs.js

@@ -1,19 +1,19 @@
-const { struct } = require("../models/struct");
-const fs = require("fs");
+const { struct } = require('../models/struct');
+const fs = require('fs');
 
 const file = (module.exports.file = struct({
-  path: "",
-  content: "",
+	path: '',
+	content: '',
 }));
 
 const readFile = (module.exports.readFile = function readFile(file) {
-  return (file.content = fs.readFileSync(file.path, { encoding: "utf-8" }));
+	return (file.content = fs.readFileSync(file.path, { encoding: 'utf-8' }));
 });
 
 module.exports.getFile = function (filepath) {
-  const f = file({
-    path: filepath,
-  });
-  readFile(f);
-  return f;
+	const f = file({
+		path: filepath,
+	});
+	readFile(f);
+	return f;
 };

package/lib/rew/modules/runtime.js

@@ -1,28 +1,24 @@
-const vm = require("vm");
-const { compileFile } = require("./compiler");
-const { prepareContext } = require("./context");
+const vm = require('vm');
+const { compileFile } = require('./compiler');
+const { prepareContext } = require('./context');
 
 const exec = (module.exports.exec = function (code, context) {
-  return vm.runInNewContext(code, vm.createContext(context), {
-    filename: context.module.filepath,
-    lineOffset: 0,
-    displayErrors: true
-  });
+	return vm.runInNewContext(code, vm.createContext(context), {
+		filename: context.module.filepath,
+		lineOffset: 0,
+		displayErrors: true,
+	});
 });
 
-module.exports.runPath = function runPath(
-  filepath,
-  options = {},
-  custom_context = {},
-) {
-  const { compiled_code, file } = compileFile(filepath, options);
-  const context = prepareContext(custom_context, options, file.path, runPath);
+module.exports.runPath = function runPath(filepath, options = {}, custom_context = {}) {
+	const { compiled_code, file } = compileFile(filepath, options);
+	const context = prepareContext(custom_context, options, file.path, runPath);
 
-  context.module.compiled = compiled_code;
-  context.process.exit = (int) => process.exit(int);
+	context.module.compiled = compiled_code;
+	context.process.exit = (int) => process.exit(int);
 
-  return {
-    context,
-    returns: exec(compiled_code, context),
-  };
+	return {
+		context,
+		returns: exec(compiled_code, context),
+	};
 };

package/lib/rew/modules/yaml.js

@@ -1,36 +1,33 @@
-const yaml = require("js-yaml");
-const path = require("path");
-const { getFile } = require("./fs");
+const yaml = require('js-yaml');
+const path = require('path');
+const { getFile } = require('./fs');
 
 function yamlFile(file) {
-  const schema = new yaml.Schema([
-    new yaml.Type("!import", {
-      kind: "scalar",
-      construct: (p) => importYaml(path.resolve(path.dirname(file.path), p)),
-    }),
-    new yaml.Type("!int", {
-      kind: "scalar",
-      construct: (data) => parseInt(data),
-    }),
-    new yaml.Type("!float", {
-      kind: "scalar",
-      construct: (data) => parseFloat(data),
-    }),
-    new yaml.Type("!bool", {
-      kind: "scalar",
-      construct: (data) => (data == "true" ? true : false),
-    }),
-  ]);
+	const schema = new yaml.Schema([
+		new yaml.Type('!import', {
+			kind: 'scalar',
+			construct: (p) => importYaml(path.resolve(path.dirname(file.path), p)),
+		}),
+		new yaml.Type('!int', {
+			kind: 'scalar',
+			construct: (data) => parseInt(data),
+		}),
+		new yaml.Type('!float', {
+			kind: 'scalar',
+			construct: (data) => parseFloat(data),
+		}),
+		new yaml.Type('!bool', {
+			kind: 'scalar',
+			construct: (data) => (data == 'true' ? true : false),
+		}),
+	]);
 
-  return yaml.load(file.content, { schema });
+	return yaml.load(file.content, { schema });
 }
 
-const importYaml = (module.exports.importYaml = function importYaml(
-  filepath,
-  file,
-) {
-  if (!file) {
-    file = getFile(filepath);
-  }
-  return yamlFile(file);
+const importYaml = (module.exports.importYaml = function importYaml(filepath, file) {
+	if (!file) {
+		file = getFile(filepath);
+	}
+	return yamlFile(file);
 });

package/lib/rew/pkgs/conf.js

@@ -1,92 +1,99 @@
 const fs = require('fs');
 const jsYaml = require('js-yaml');
 const path = require('path');
-
-const CONFIG_PATH = path.resolve(process.env.HOME, '.config/rew');
+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;
-}
+	const rootPath = path.join(CONFIG_PATH, packageName);
+	fs.mkdirSync(rootPath, { recursive: true });
+	return rootPath;
+};
 
 module.exports = (context) => ({
-  CONFIG_PATH,
-  create: (packageName) => {
-    const rootPath = createPackageRoot(packageName);
+	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 conf = {};
+		const dumpYaml = (val) => {
+			if (JSON.stringify(val) == '{}') return '';
+			else return jsYaml.dump(val);
+		};
 
-    const dumpYaml = (val) => {
-      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 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 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 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 });
+					fs.writeFileSync(fileRoot, value || defaultValue);
+				},
+				fileRoot,
+				exists,
+			};
+		};
 
-    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 }); 
-          fs.writeFileSync(fileRoot, value || defaultValue);
-        },
-        fileRoot,
-        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)) {
-        conf[name] = defaults;
-        fs.writeFileSync(optionRoot, dumpYaml(defaults));
-      } else {
-        conf[name] = jsYaml.load(fs.readFileSync(optionRoot, { encoding: 'utf-8' }));
-      }
+		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)) {
+				conf[name] = defaults;
+				fs.writeFileSync(optionRoot, dumpYaml(defaults));
+			} else {
+				conf[name] = jsYaml.load(fs.readFileSync(optionRoot, { encoding: 'utf-8' }));
+			}
 
-      const optionCenter = {
-        root: optionRoot,
-        name,
-        package: packageName
-      }
+			const optionCenter = {
+				root: optionRoot,
+				name,
+				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
-      }
-    }
+			return {
+				get: (key, defaultValue) => getData(optionCenter, key) || defaultValue,
+				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,
+			};
+		};
 
-    const defaultCenter = createOptionCenter('_default', { default: true });
+		const defaultCenter = createOptionCenter('_default', { default: true });
 
-    return {
-      optionCenter: createOptionCenter,
-      staticFile: staticFile,
-      set: (key, value) => defaultCenter.set(key, value),
-      get: (key) => defaultCenter.get(key),
-      remove: (key) => defaultCenter.remove(key),
-      root: rootPath,
-      package: packageName
-    }
-  }
-});
+		return {
+			optionCenter: createOptionCenter,
+			staticFile: staticFile,
+			set: (key, value) => defaultCenter.set(key, value),
+			get: (key, defaultValue) => defaultCenter.get(key, defaultValue),
+			remove: (key) => defaultCenter.remove(key),
+			root: rootPath,
+			package: packageName,
+		};
+	},
+});

package/lib/rew/pkgs/data.js

@@ -1,8 +1,13 @@
-const { BinaryTree } = require("./modules/data/bintree");
-const { DoublyLinkedList } = require("./modules/data/doublylinked");
-const { LinkedList } = require("./modules/data/linkedList");
-const { Queue } = require("./modules/data/queue");
-const { Stack } = require("./modules/data/stack");
+const { BinaryTree } = require('./modules/data/bintree');
+const { DoublyLinkedList } = require('./modules/data/doublylinked');
+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

@@ -8,10 +8,10 @@
  * @return {string} - The formatted date string.
  */
 function formatDate(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
-  return `${year}-${month}-${day}`;
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, '0');
+	const day = String(date.getDate()).padStart(2, '0');
+	return `${year}-${month}-${day}`;
 }
 
 /**
@@ -20,10 +20,10 @@ 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');
-  return `${hours}:${minutes}:${seconds}`;
+	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}`;
 }
 
 // Parsing Functions
@@ -34,8 +34,8 @@ function formatTime(date) {
  * @return {Date} - The parsed date object.
  */
 function parseDate(dateString) {
-  const [year, month, day] = dateString.split('-').map(Number);
-  return new Date(year, month - 1, day);
+	const [year, month, day] = dateString.split('-').map(Number);
+	return new Date(year, month - 1, day);
 }
 
 /**
@@ -44,10 +44,10 @@ function parseDate(dateString) {
  * @return {Date} - The parsed date object.
  */
 function parseTime(timeString) {
-  const [hours, minutes, seconds] = timeString.split(':').map(Number);
-  const date = new Date();
-  date.setHours(hours, minutes, seconds, 0);
-  return date;
+	const [hours, minutes, seconds] = timeString.split(':').map(Number);
+	const date = new Date();
+	date.setHours(hours, minutes, seconds, 0);
+	return date;
 }
 
 // Arithmetic Functions
@@ -59,9 +59,9 @@ function parseTime(timeString) {
  * @return {Date} - The new date object.
  */
 function addDays(date, days) {
-  const result = new Date(date);
-  result.setDate(result.getDate() + days);
-  return result;
+	const result = new Date(date);
+	result.setDate(result.getDate() + days);
+	return result;
 }
 
 /**
@@ -71,7 +71,7 @@ function addDays(date, days) {
  * @return {Date} - The new date object.
  */
 function subtractDays(date, days) {
-  return addDays(date, -days);
+	return addDays(date, -days);
 }
 
 /**
@@ -81,18 +81,17 @@ function subtractDays(date, days) {
  * @return {number} - The difference in days.
  */
 function differenceInDays(date1, date2) {
-  const diffTime = date2 - date1;
-  return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+	const diffTime = date2 - date1;
+	return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
 }
 
-
 // Exporting the functions as a CommonJS module
 module.exports = () => ({
-  formatDate,
-  formatTime,
-  parseDate,
-  parseTime,
-  addDays,
-  subtractDays,
-  differenceInDays
+	formatDate,
+	formatTime,
+	parseDate,
+	parseTime,
+	addDays,
+	subtractDays,
+	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,
-  rm: (key) => delete process.env[key],
-  is: (key, value) => process.env[key] == value
-})
+	has: (key) => key in process.env,
+	get: (key) => process.env[key],
+	set: (key, value) => (process.env[key] = value),
+	rm: (key) => delete process.env[key],
+	is: (key, value) => process.env[key] == value,
+});