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

@makano/rew 1.0.1

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
+});