npm - @makano/rew - Versions diffs - 1.0.1 - Mend

@makano/rew 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/bin/rew +9 -0
package/bin/ui +0 -0
package/bin/webkit_app +0 -0
package/lib/coffeescript/browser.js +151 -0
package/lib/coffeescript/cake.js +135 -0
package/lib/coffeescript/coffeescript.js +409 -0
package/lib/coffeescript/command.js +750 -0
package/lib/coffeescript/grammar.js +2496 -0
package/lib/coffeescript/helpers.js +477 -0
package/lib/coffeescript/index.js +217 -0
package/lib/coffeescript/lexer.js +1943 -0
package/lib/coffeescript/nodes.js +9204 -0
package/lib/coffeescript/optparse.js +230 -0
package/lib/coffeescript/parser.js +1344 -0
package/lib/coffeescript/register.js +100 -0
package/lib/coffeescript/repl.js +305 -0
package/lib/coffeescript/rewriter.js +1138 -0
package/lib/coffeescript/scope.js +187 -0
package/lib/coffeescript/sourcemap.js +229 -0
package/lib/rew/cli/cli.js +117 -0
package/lib/rew/cli/log.js +40 -0
package/lib/rew/cli/run.js +20 -0
package/lib/rew/cli/utils.js +122 -0
package/lib/rew/const/default.js +35 -0
package/lib/rew/const/files.js +15 -0
package/lib/rew/css/theme.css +3 -0
package/lib/rew/functions/core.js +85 -0
package/lib/rew/functions/emitter.js +57 -0
package/lib/rew/functions/export.js +9 -0
package/lib/rew/functions/future.js +22 -0
package/lib/rew/functions/id.js +13 -0
package/lib/rew/functions/import.js +57 -0
package/lib/rew/functions/map.js +17 -0
package/lib/rew/functions/match.js +34 -0
package/lib/rew/functions/sleep.js +5 -0
package/lib/rew/functions/types.js +96 -0
package/lib/rew/html/ui.html +223 -0
package/lib/rew/main.js +17 -0
package/lib/rew/models/enum.js +14 -0
package/lib/rew/models/struct.js +41 -0
package/lib/rew/modules/compiler.js +17 -0
package/lib/rew/modules/context.js +50 -0
package/lib/rew/modules/fs.js +19 -0
package/lib/rew/modules/runtime.js +24 -0
package/lib/rew/modules/utils.js +0 -0
package/lib/rew/modules/yaml.js +36 -0
package/lib/rew/pkgs/conf.js +92 -0
package/lib/rew/pkgs/data.js +8 -0
package/lib/rew/pkgs/date.js +98 -0
package/lib/rew/pkgs/modules/data/bintree.js +66 -0
package/lib/rew/pkgs/modules/data/doublylinked.js +100 -0
package/lib/rew/pkgs/modules/data/linkedList.js +88 -0
package/lib/rew/pkgs/modules/data/queue.js +28 -0
package/lib/rew/pkgs/modules/data/stack.js +27 -0
package/lib/rew/pkgs/modules/ui/classes.js +171 -0
package/lib/rew/pkgs/pkgs.js +13 -0
package/lib/rew/pkgs/ui.js +108 -0
package/package.json +41 -0

package/lib/rew/html/ui.html ADDED Viewed

@@ -0,0 +1,223 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>$OPTIONS(title)</title>
+    <style>/* $OPTIONS(style) */</style>
+    <script>
+      window.execContext = $OPTIONS(json.execContext);
+    </script>
+    <script>
+      window.exec = $OPTIONS(exec);
+    </script>
+    <script>
+      if(!window.execContext) window.execContext = {};
+      window.addEventListener("load", () => {
+        const ws = new WebSocket("ws://localhost:$OPTIONS(port)");
+        const DOM = [];
+        const findInDom = (id) =>
+          DOM.find((el) => el.widgetOptions.uuid == id) ||
+          DOM.find((el) => el.id == id);
+        const parseStyleValue = (val) => val;
+        const addTo = (el, parent) => {
+          if (parent == "null") {
+            document.body.appendChild(el);
+          } else {
+            findInDom(parent).appendChild(el);
+          }
+        };
+        const initElement = (el, options, update = false) => {
+          if(el.widgetOptions){
+            if (el.widgetOptions.style) {
+              for(let i in options.style){
+                el.style.removeProperty(i, el.widgetOptions.style[i]);
+              }
+            }
+            if (el.widgetOptions.attr) {
+              for(let i in el.widgetOptions.attr){
+                el.removeAttribute(i);
+              }
+            }
+          }
+          el.widgetOptions = options;
+          el.id = options.id;
+          el.textContent = options.data.text;
+          if (options.style) {
+            for(let i in options.style){
+              el.style.setProperty(i, options.style[i]);
+            }
+          }
+          if (options.attr) {
+            for(let i in options.attr){
+              el.setAttribute(i, options.attr[i]);
+            }
+          }
+          if (options.children.length) {
+            options.children.forEach((option) => {
+              option.parent = options.uuid;
+              if(update) updateElement(findInDom(option.uuid), option);
+              else createElement(option);
+            });
+          }
+          if (options.parent) {
+            addTo(el, options.parent);
+          }
+        }
+        const updateElement = (el, options) => {
+          if(!el) return;
+          initElement(el, options, true);
+          return el;
+        }
+        const events = [
+          "click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout",
+          "mousemove", "mouseenter", "mouseleave", "keydown", "keypress", "keyup",
+          "change", "input", "submit", "focus", "blur", "copy", "cut", "paste",
+          "scroll", "wheel", "resize", "contextmenu", "drag", "dragstart", "dragend",
+          "dragenter", "dragleave", "dragover", "drop", "error", "load", "abort"
+        ];
+        const handleListeners = (el) => {
+          events.forEach(event => {
+            el.addEventListener(event, (e) => {
+              ws.send(JSON.stringify({
+                action: 'hook:eventTrigger',
+                data: {
+                  rid: 'event_trigger',
+                  object: {
+                    uuid: el.widgetOptions.uuid,
+                    event,
+                    data: {
+                      mouse: { x: e.clientX, y: e.clientY },
+                      key: { code: e.keyCode, key: e.key }
+                    }
+                  }
+                }
+              }))
+            });
+          });
+        }
+        function eventHandlerFunction({ uuid, hookID, event }){
+          return function(e){
+            ws.send(JSON.stringify({
+              action: 'hook:event_'+event,
+              data: {
+                rid: hookID,
+                object: {
+                  uuid,
+                  event,
+                  data: {
+                    mouse: { x: e.clientX, y: e.clientY },
+                    key: { code: e.keyCode, key: e.key }
+                  }
+                }
+              }
+            }));
+          }
+        }
+        const createElement = (options) => {
+          const el = document.createElement(options.element);
+          DOM.push(el);
+          initElement(el, options);
+          return el;
+        };
+        const stringifyJSON = (json) => {
+          try {
+            return JSON.stringify(json, null, 4);
+          } catch (e) {
+            return json.toString();
+          }
+        };
+        const log = (...strings) => {
+          window.webkit.messageHandlers.external.postMessage(
+            JSON.stringify({"action": "log", "data": strings
+              .map((r) =>
+                typeof r == "object" ? stringifyJSON(r) : `${r.toString()}`,
+              )
+              // .map((i) => i.replace(/\"/g, '\\\\"').replace(/\n/g, "\\\\n"))
+              .join("\n")}, null, 4)
+          );
+        };
+        if (
+          window.webkit &&
+          window.webkit.messageHandlers &&
+          window.webkit.messageHandlers.external &&
+          window.RUNID == "$OPTIONS(runId)"
+        ) {
+          ws.onmessage = (event, cb) => {
+            const edata = process_data(event.data);
+            if (edata.action == "init") {
+              document.title = edata.data.title;
+              window.webkit.messageHandlers.external.postMessage(
+                `{"action": "setTitle", "data": "${edata.data.title}"}`,
+              );
+              log("INIT::READY");
+              if(window.exec){
+                window.exec(window.execContext);
+              }
+            } else if(edata.action == 'eventListen') {
+              const el = findInDom(edata.data.uuid);
+              if(el){
+                el.addEventListener(edata.data.event, eventHandlerFunction(edata.data))
+              }
+            } else if (edata.action == "createElement") {
+              const options = edata.data;
+              try {
+                createElement(options);
+              } catch (e) {
+                log(e.toString());
+              }
+            } else if (edata.action == "addStyleSheet") {
+              const style = document.createElement('style');
+              style.textContent = edata.data;
+              document.head.appendChild(style);
+            } else if (edata.action == "updateElement") {
+              const options = edata.data;
+              try {
+                updateElement(findInDom(options.uuid), options);
+              } catch (e) {
+                log(e.toString());
+              }
+            } else if (edata.action == "findElement") {
+              const id = edata.data.id;
+              const rid = edata.data.rid;
+              try {
+                ws.send(JSON.stringify({ action: 'hook:findElement', data: { rid, object: findInDom(id)?.widgetOptions }  }))
+              } catch (e) {
+                log(e.toString());
+              }
+            }
+          };
+        } else {
+          console.log("Not in a webkit window");
+        }
+        function process_data(data) {
+          return JSON.parse(data);
+        }
+      });
+    </script>
+  </head>
+  <body>
+  </body>
+</html>

package/lib/rew/main.js ADDED Viewed

@@ -0,0 +1,17 @@
+const { compileFile } = require("./modules/compiler");
+const { exec, runPath } = require("./modules/runtime");
+const fs = require("fs");
+const { imp } = require("./functions/import");
+const { FILES } = require("./const/files");
+module.exports.run = function (filepath, options = {}, custom_context = {}) {
+  FILES.forEach(file => {
+    if(fs.existsSync(file.path)) return;
+    if(file.content){
+      fs.writeFileSync(file.path, file.content);
+    } else {
+      fs.mkdirSync(file.path, { recursive: true });
+    }
+  });
+  return runPath(filepath, options, custom_context);
+};

package/lib/rew/models/enum.js ADDED Viewed

@@ -0,0 +1,14 @@
+module.exports.cenum = function cenum(values) {
+  var enumObj, i, len, value;
+  // Create an object to hold the enum values
+  enumObj = {};
+  for (i = 0, len = values.length; i < len; i++) {
+    value = values[i];
+    enumObj[value] = value;
+  }
+  // Add a method to check if a value is a valid enum value
+  enumObj.isValid = function (val) {
+    return indexOf.call(enumObj, val) >= 0;
+  };
+  return enumObj;
+};

package/lib/rew/models/struct.js ADDED Viewed

@@ -0,0 +1,41 @@
+const { generateRandomID } = require("../functions/id");
+module.exports.struct = function struct(template) {
+  var key, types, value;
+  types = {};
+  for (key in template) {
+    value = template[key];
+    types[key] = typeof value;
+  }
+  const fun = function (properties = {}) {
+    var defaultValue, instance;
+    instance = {};
+    for (key in template) {
+      defaultValue = template[key];
+      if (key in properties) {
+        value = properties[key];
+        if (defaultValue != "!any" && typeof value !== types[key]) {
+          throw new Error(
+            `Type error: Expected ${types[key]} for ${key}, got ${typeof value}`,
+          );
+        }
+        instance[key] = value;
+      } else {
+        instance[key] = defaultValue == "!any" ? null : defaultValue;
+      }
+    }
+    instance.__proto__ = { '@instance': fun };
+    return instance;
+  };
+  return fun;
+};
+module.exports.struct.inherits = function (struct, template) {
+  return module.exports.struct({
+    ...struct(),
+    ...template,
+  });
+};

package/lib/rew/modules/compiler.js ADDED Viewed

@@ -0,0 +1,17 @@
+const { compile } = require("../../coffeescript/coffeescript");
+const { getFile } = require("./fs");
+const cpl = (module.exports.compile = function (file, options = {}) {
+  return compile(file.content, options);
+});
+module.exports.compileFile = function (filepath, options = {}) {
+  const f = getFile(filepath);
+  const compiled_code =
+    options.compile == false ? f.content : cpl(f, { ...options });
+  return {
+    compiled_code,
+    file: f,
+  };
+};

package/lib/rew/modules/context.js ADDED Viewed

@@ -0,0 +1,50 @@
+const defaultContext = require("../const/default");
+const emitter = require("../functions/emitter");
+const { exportsFunction } = require("../functions/export");
+const { imp } = require("../functions/import");
+module.exports.prepareContext = function (
+  custom_context,
+  options,
+  filepath = "",
+  runPath = () => {},
+) {
+  let context = {
+    module: {
+      exports: null,
+      options,
+      filepath,
+      imports: []
+    },
+  };
+  if (options.useContext) {
+    context = {
+      ...context,
+      ...custom_context,
+    };
+  } else {
+    context = {
+      ...context,
+      ...defaultContext,
+      require: (package) => {
+        try {
+          return require(package);
+        } catch (e) {
+          throw new Error("Module not found");
+        }
+      },
+      ...custom_context,
+    };
+    context.imp = imp(runPath, context);
+    context.exports = exportsFunction(context);
+  }
+  if (!context.global) context.global = context;
+  if (!context.process)
+    context.process = {
+      argv: process.argv,
+      target: emitter(),
+      env: process.env,
+    };
+  // console.log(custom_context);
+  return context;
+};

package/lib/rew/modules/fs.js ADDED Viewed

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

package/lib/rew/modules/runtime.js ADDED Viewed

@@ -0,0 +1,24 @@
+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));
+});
+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);
+  return {
+    context,
+    returns: exec(compiled_code, context),
+  };
+};

package/lib/rew/modules/utils.js ADDED Viewed

File without changes

package/lib/rew/modules/yaml.js ADDED Viewed

@@ -0,0 +1,36 @@
+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),
+    }),
+  ]);
+  return yaml.load(file.content, { schema });
+}
+const importYaml = (module.exports.importYaml = function importYaml(
+  filepath,
+  file,
+) {
+  if (!file) {
+    file = getFile(filepath);
+  }
+  return yamlFile(file);
+});

package/lib/rew/pkgs/conf.js ADDED Viewed

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const jsYaml = require('js-yaml');
+const path = require('path');
+const CONFIG_PATH = path.resolve(process.env.HOME, '.config/rew');
+const createPackageRoot = (packageName) => {
+  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);
+    const conf = {};
+    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 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 });
+          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 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
+      }
+    }
+    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
+    }
+  }
+});

package/lib/rew/pkgs/data.js ADDED Viewed

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

package/lib/rew/pkgs/date.js ADDED Viewed

@@ -0,0 +1,98 @@
+// Date and Time Module
+// Formatting Functions
+/**
+ * Format a date object to a string (YYYY-MM-DD).
+ * @param {Date} date - The date object.
+ * @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}`;
+}
+/**
+ * Format a time object to a string (HH:MM:SS).
+ * @param {Date} date - The date object.
+ * @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}`;
+}
+// Parsing Functions
+/**
+ * Parse a date string (YYYY-MM-DD) into a date object.
+ * @param {string} dateString - The date string.
+ * @return {Date} - The parsed date object.
+ */
+function parseDate(dateString) {
+  const [year, month, day] = dateString.split('-').map(Number);
+  return new Date(year, month - 1, day);
+}
+/**
+ * Parse a time string (HH:MM:SS) into a date object.
+ * @param {string} timeString - The time string.
+ * @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;
+}
+// Arithmetic Functions
+/**
+ * Add days to a date.
+ * @param {Date} date - The date object.
+ * @param {number} days - The number of days to add.
+ * @return {Date} - The new date object.
+ */
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+/**
+ * Subtract days from a date.
+ * @param {Date} date - The date object.
+ * @param {number} days - The number of days to subtract.
+ * @return {Date} - The new date object.
+ */
+function subtractDays(date, days) {
+  return addDays(date, -days);
+}
+/**
+ * Calculate the difference in days between two dates.
+ * @param {Date} date1 - The first date object.
+ * @param {Date} date2 - The second date object.
+ * @return {number} - The difference in days.
+ */
+function differenceInDays(date1, date2) {
+  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
+});