leanweb 1.3.5 → 2.0.0

package/templates/lib/lw-event-bus.js

@@ -1,17 +1,17 @@
 class LWEvent {
-   constructor(eventName, data) {
-      this.eventName = eventName;
-      this.data = data;
-   }
+  constructor(eventName, data) {
+    this.eventName = eventName;
+    this.data = data;
+  }
 }
 
 class LWEventListener {
-   static key = 0;
-   constructor(eventName, callback) {
-      this.eventName = eventName;
-      this.callback = callback;
-      this.key = ++LWEventListener.key;
-   }
+  static key = 0;
+  constructor(eventName, callback) {
+    this.eventName = eventName;
+    this.callback = callback;
+    this.key = ++LWEventListener.key;
+  }
 }
 
 // const listeners = {
@@ -24,31 +24,31 @@ class LWEventListener {
 // };
 
 export default class LWEventBus {
-   constructor() {
-      this.listeners = {};
-   }
+  constructor() {
+    this.listeners = {};
+  }
 
-   addEventListener(eventName, callback) {
-      const listener = new LWEventListener(eventName, callback);
-      this.listeners[listener.eventName] = this.listeners[listener.eventName] || {};
-      const events = this.listeners[listener.eventName];
-      events[listener.key] = listener;
-      return listener;
-   }
+  addEventListener(eventName, callback) {
+    const listener = new LWEventListener(eventName, callback);
+    this.listeners[listener.eventName] = this.listeners[listener.eventName] || {};
+    const events = this.listeners[listener.eventName];
+    events[listener.key] = listener;
+    return listener;
+  }
 
-   removeEventListener(listener) {
-      if (this.listeners[listener.eventName]) {
-         delete this.listeners[listener.eventName][listener.key];
-      }
-   }
+  removeEventListener(listener) {
+    if (this.listeners[listener.eventName]) {
+      delete this.listeners[listener.eventName][listener.key];
+    }
+  }
 
-   dispatchEvent(eventName, data = null) {
-      if (this.listeners[eventName]) {
-         Object.values(this.listeners[eventName]).forEach(listener => {
-            setTimeout(() => {
-               listener.callback.call(void 0, new LWEvent(eventName, data));
-            });
-         });
-      }
-   }
+  dispatchEvent(eventName, data = null) {
+    if (this.listeners[eventName]) {
+      Object.values(this.listeners[eventName]).forEach(listener => {
+        setTimeout(() => {
+          listener.callback.call(void 0, new LWEvent(eventName, data));
+        });
+      });
+    }
+  }
 }

package/templates/lib/lw-expr-parser.js

@@ -1,194 +1,194 @@
 const binaryOperations = {
-   '==': (a, b) => a == b,
-   '!=': (a, b) => a != b,
-   '===': (a, b) => a === b,
-   '!==': (a, b) => a !== b,
-   '<': (a, b) => a < b,
-   '<=': (a, b) => a <= b,
-   '>': (a, b) => a > b,
-   '>=': (a, b) => a >= b,
-   '<<': (a, b) => a << b,
-   '>>': (a, b) => a >> b,
-   '>>>': (a, b) => a >>> b,
-   '+': (a, b) => a + b,
-   '-': (a, b) => a - b,
-   '*': (a, b) => a * b,
-   '/': (a, b) => a / b,
-   '%': (a, b) => a % b,
-   '**': (a, b) => a ** b,
-   '|': (a, b) => a | b,
-   '^': (a, b) => a ^ b,
-   '&': (a, b) => a & b,
-   'in': (a, b) => a in b,
-   'instanceof': (a, b) => a instanceof b,
-   //  '|>': (a, b) => a |> b,
+  '==': (a, b) => a == b,
+  '!=': (a, b) => a != b,
+  '===': (a, b) => a === b,
+  '!==': (a, b) => a !== b,
+  '<': (a, b) => a < b,
+  '<=': (a, b) => a <= b,
+  '>': (a, b) => a > b,
+  '>=': (a, b) => a >= b,
+  '<<': (a, b) => a << b,
+  '>>': (a, b) => a >> b,
+  '>>>': (a, b) => a >>> b,
+  '+': (a, b) => a + b,
+  '-': (a, b) => a - b,
+  '*': (a, b) => a * b,
+  '/': (a, b) => a / b,
+  '%': (a, b) => a % b,
+  '**': (a, b) => a ** b,
+  '|': (a, b) => a | b,
+  '^': (a, b) => a ^ b,
+  '&': (a, b) => a & b,
+  'in': (a, b) => a in b,
+  'instanceof': (a, b) => a instanceof b,
+  //  '|>': (a, b) => a |> b,
 };
 
 const assignmentOperations = {
-   '=': (c, a, b) => { c[a] = b; },
-   '+=': (c, a, b) => { c[a] += b; },
-   '-=': (c, a, b) => { c[a] -= b; },
-   '*=': (c, a, b) => { c[a] *= b; },
-   '/=': (c, a, b) => { c[a] /= b; },
-   '%=': (c, a, b) => { c[a] %= b; },
-   '**=': (c, a, b) => { c[a] **= b; },
-   '&&=': (c, a, b) => { c[a] &&= b; },
-   '??=': (c, a, b) => { c[a] ??= b; },
-   '||=': (c, a, b) => { c[a] ||= b; },
-   '>>=': (c, a, b) => { c[a] >>= b; },
-   '>>>=': (c, a, b) => { c[a] >>>= b; },
-   '<<=': (c, a, b) => { c[a] <<= b; },
-   '&=': (c, a, b) => { c[a] &= b; },
-   '|=': (c, a, b) => { c[a] |= b; },
-   '^=': (c, a, b) => { c[a] ^= b; },
+  '=': (c, a, b) => { c[a] = b; },
+  '+=': (c, a, b) => { c[a] += b; },
+  '-=': (c, a, b) => { c[a] -= b; },
+  '*=': (c, a, b) => { c[a] *= b; },
+  '/=': (c, a, b) => { c[a] /= b; },
+  '%=': (c, a, b) => { c[a] %= b; },
+  '**=': (c, a, b) => { c[a] **= b; },
+  '&&=': (c, a, b) => { c[a] &&= b; },
+  '??=': (c, a, b) => { c[a] ??= b; },
+  '||=': (c, a, b) => { c[a] ||= b; },
+  '>>=': (c, a, b) => { c[a] >>= b; },
+  '>>>=': (c, a, b) => { c[a] >>>= b; },
+  '<<=': (c, a, b) => { c[a] <<= b; },
+  '&=': (c, a, b) => { c[a] &= b; },
+  '|=': (c, a, b) => { c[a] |= b; },
+  '^=': (c, a, b) => { c[a] ^= b; },
 };
 
 const logicalOperators = {
-   '||': (a, b) => a || b,
-   '&&': (a, b) => a && b,
-   '??': (a, b) => a ?? b,
+  '||': (a, b) => a || b,
+  '&&': (a, b) => a && b,
+  '??': (a, b) => a ?? b,
 };
 
 const unaryOperators = {
-   '-': a => -a,
-   '+': a => +a,
-   '!': a => !a,
-   '~': a => ~a,
-   'typeof': a => typeof a,
-   'void': a => void a,
-   // 'delete': a => delete a,
-   'throw': a => { throw a; },
+  '-': a => -a,
+  '+': a => +a,
+  '!': a => !a,
+  '~': a => ~a,
+  'typeof': a => typeof a,
+  'void': a => void a,
+  // 'delete': a => delete a,
+  'throw': a => { throw a; },
 };
 
 const updateOperators = (operator, prefix) => {
-   if (operator === '++') {
-      return (c, a) => prefix ? ++c[a] : c[a]++;
-   } else if (operator === '--') {
-      return (c, a) => prefix ? --c[a] : c[a]--;
-   }
+  if (operator === '++') {
+    return (c, a) => prefix ? ++c[a] : c[a]++;
+  } else if (operator === '--') {
+    return (c, a) => prefix ? --c[a] : c[a]--;
+  }
 };
 
 const callFunction = (node, context) => {
-   const callee = evalNode(node.callee, context);
-   if (node.callee.type === 'OptionalMemberExpression' && (callee === void 0 || callee === null)) {
-      return void 0;
-   }
-   const args = [];
-   node.arguments.map(argument => {
-      if (argument.type === 'SpreadElement') {
-         args.push(...evalNode(argument, context));
-      } else {
-         args.push(evalNode(argument, context));
-      }
-   });
-   return callee(...args);
+  const callee = evalNode(node.callee, context);
+  if (node.callee.type === 'OptionalMemberExpression' && (callee === void 0 || callee === null)) {
+    return void 0;
+  }
+  const args = [];
+  node.arguments.map(argument => {
+    if (argument.type === 'SpreadElement') {
+      args.push(...evalNode(argument, context));
+    } else {
+      args.push(evalNode(argument, context));
+    }
+  });
+  return callee(...args);
 };
 
 const nodeHandlers = {
-   'NumericLiteral': (node, context) => node.value,
-   'StringLiteral': (node, context) => node.value,
-   'BooleanLiteral': (node, context) => node.value,
-   'NullLiteral': (node, context) => null,
-
-   'RegExpLiteral': (node, context) => new RegExp(node.pattern, node.flags),
-
-   'ExpressionStatement': (node, context) => evalNode(node.expression, context),
-   'BinaryExpression': (node, context) => binaryOperations[node.operator](evalNode(node.left, context), evalNode(node.right, context)),
-   'AssignmentExpression': (node, context) => {
-      const immediateCtx = immediateContext(node.left, context);
-      assignmentOperations[node.operator](immediateCtx, node.left.name, evalNode(node.right, context));
-   },
-   'LogicalExpression': (node, context) => logicalOperators[node.operator](evalNode(node.left, context), evalNode(node.right, context)),
-   'UnaryExpression': (node, context) => unaryOperators[node.operator](evalNode(node.argument, context)),
-   'UpdateExpression': (node, context) => {
-      const immediateCtx = immediateContext(node.argument, context);
-      updateOperators(node.operator, node.prefix)(immediateCtx, node.argument.name, evalNode(node.argument, context));
-   },
-   'ConditionalExpression': (node, context) => {
-      const test = evalNode(node.test, context);
-      const consequent = evalNode(node.consequent, context);
-      const alternate = evalNode(node.alternate, context);
-      return test ? consequent : alternate;
-   },
-   'MemberExpression': (node, context) => {
-      const object = evalNode(node.object, context);
-      const member = node.computed ? object[evalNode(node.property, context)] : object[node.property.name];
-      if (typeof member === 'function') {
-         return member.bind(object);
-      }
-      return member;
-   },
-   'OptionalMemberExpression': (node, context) => {
-      const object = evalNode(node.object, context);
-      if (object === void 0 || object === null) {
-         return void 0;
-      }
-      const member = node.computed ? (object[evalNode(node.property, context)]) : (object[node.property.name]);
-      if (typeof member === 'function') {
-         return member.bind(object);
-      }
-      return member;
-   },
-
-   'ArrayExpression': (node, context) => {
-      const arr = [];
-      node.elements.map(elem => {
-         if (elem.type === 'SpreadElement') {
-            arr.push(...evalNode(elem, context));
-         } else {
-            arr.push(evalNode(elem, context));
-         }
-      });
-      return arr;
-   },
-   'ObjectExpression': (node, context) => node.properties.reduce((acc, prop) => ({ ...acc, ...evalNode(prop, context) }), {}),
-   'ObjectProperty': (node, context) => ({ [evalNode(node.key, context)]: evalNode(node.value, context) }),
-   'SpreadElement': (node, context) => evalNode(node.argument, context),
-
-   'Identifier': (node, context) => {
-      if (Array.isArray(context)) {
-         const hitContext = context.find(contextObj => node.name in contextObj);
-         return hitContext ? hitContext[node.name] : undefined;
-      } else if (typeof context === 'object') {
-         return context[node.name];
-      }
-   },
-   'ThisExpression': (node, context) => {
-      if (Array.isArray(context)) {
-         const hitContext = context.find(contextObj => 'this' in contextObj);
-         return hitContext ? hitContext['this'] : undefined;
-      } else if (typeof context === 'object') {
-         return context['this'];
+  'NumericLiteral': (node, context) => node.value,
+  'StringLiteral': (node, context) => node.value,
+  'BooleanLiteral': (node, context) => node.value,
+  'NullLiteral': (node, context) => null,
+
+  'RegExpLiteral': (node, context) => new RegExp(node.pattern, node.flags),
+
+  'ExpressionStatement': (node, context) => evalNode(node.expression, context),
+  'BinaryExpression': (node, context) => binaryOperations[node.operator](evalNode(node.left, context), evalNode(node.right, context)),
+  'AssignmentExpression': (node, context) => {
+    const immediateCtx = immediateContext(node.left, context);
+    assignmentOperations[node.operator](immediateCtx, node.left.name, evalNode(node.right, context));
+  },
+  'LogicalExpression': (node, context) => logicalOperators[node.operator](evalNode(node.left, context), evalNode(node.right, context)),
+  'UnaryExpression': (node, context) => unaryOperators[node.operator](evalNode(node.argument, context)),
+  'UpdateExpression': (node, context) => {
+    const immediateCtx = immediateContext(node.argument, context);
+    updateOperators(node.operator, node.prefix)(immediateCtx, node.argument.name, evalNode(node.argument, context));
+  },
+  'ConditionalExpression': (node, context) => {
+    const test = evalNode(node.test, context);
+    const consequent = evalNode(node.consequent, context);
+    const alternate = evalNode(node.alternate, context);
+    return test ? consequent : alternate;
+  },
+  'MemberExpression': (node, context) => {
+    const object = evalNode(node.object, context);
+    const member = node.computed ? object[evalNode(node.property, context)] : object[node.property.name];
+    if (typeof member === 'function') {
+      return member.bind(object);
+    }
+    return member;
+  },
+  'OptionalMemberExpression': (node, context) => {
+    const object = evalNode(node.object, context);
+    if (object === void 0 || object === null) {
+      return void 0;
+    }
+    const member = node.computed ? (object[evalNode(node.property, context)]) : (object[node.property.name]);
+    if (typeof member === 'function') {
+      return member.bind(object);
+    }
+    return member;
+  },
+
+  'ArrayExpression': (node, context) => {
+    const arr = [];
+    node.elements.map(elem => {
+      if (elem.type === 'SpreadElement') {
+        arr.push(...evalNode(elem, context));
+      } else {
+        arr.push(evalNode(elem, context));
       }
-   },
-
-   'CallExpression': (node, context) => callFunction(node, context),
-   'OptionalCallExpression': (node, context) => callFunction(node, context),
-   'NewExpression': (node, context) => callFunction(node, context),
-
-   'Directive': (node, context) => evalNode(node.value, context),
-   'DirectiveLiteral': (node, context) => node.value,
+    });
+    return arr;
+  },
+  'ObjectExpression': (node, context) => node.properties.reduce((acc, prop) => ({ ...acc, ...evalNode(prop, context) }), {}),
+  'ObjectProperty': (node, context) => ({ [evalNode(node.key, context)]: evalNode(node.value, context) }),
+  'SpreadElement': (node, context) => evalNode(node.argument, context),
+
+  'Identifier': (node, context) => {
+    if (Array.isArray(context)) {
+      const hitContext = context.find(contextObj => node.name in contextObj);
+      return hitContext ? hitContext[node.name] : undefined;
+    } else if (typeof context === 'object') {
+      return context[node.name];
+    }
+  },
+  'ThisExpression': (node, context) => {
+    if (Array.isArray(context)) {
+      const hitContext = context.find(contextObj => 'this' in contextObj);
+      return hitContext ? hitContext['this'] : undefined;
+    } else if (typeof context === 'object') {
+      return context['this'];
+    }
+  },
+
+  'CallExpression': (node, context) => callFunction(node, context),
+  'OptionalCallExpression': (node, context) => callFunction(node, context),
+  'NewExpression': (node, context) => callFunction(node, context),
+
+  'Directive': (node, context) => evalNode(node.value, context),
+  'DirectiveLiteral': (node, context) => node.value,
 };
 
 const immediateContext = (node, context) => {
-   if (Array.isArray(context)) {
-      if (context.length === 0) {
-         return null;
-      }
-      return context.find(contextObj => node.name in contextObj) ?? context[0];
-   } else if (typeof context === 'object') {
-      return context;
-   }
+  if (Array.isArray(context)) {
+    if (context.length === 0) {
+      return null;
+    }
+    return context.find(contextObj => node.name in contextObj) ?? context[0];
+  } else if (typeof context === 'object') {
+    return context;
+  }
 }
 
 const evalNode = (node, context) => nodeHandlers[node.type](node, context);
 
 const evaluate = (ast, context = {}, loc = {}) => {
-   try {
-      return ast.map(astNode => evalNode(astNode, context));
-   } catch (e) {
-      throw { error: e.message, location: loc, ast, context };
-   }
+  try {
+    return ast.map(astNode => evalNode(astNode, context));
+  } catch (e) {
+    throw { error: e.message, location: loc, ast, context };
+  }
 };
 
 export { evaluate };

package/commands/electron.js

@@ -1,71 +0,0 @@
-
-import fs from 'fs';
-import fse from 'fs-extra';
-import webpack from 'webpack';
-import * as utils from './utils.js';
-
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-
-(async () => {
-   let env = '';
-   const args = process.argv;
-   if (args.length >= 3) {
-      env = args[2];
-   }
-
-   if (!fs.existsSync(process.cwd() + `/${utils.dirs.src}/electron.js`)) {
-      fse.copySync(`${__dirname}/../templates/electron.js`, `${process.cwd()}/${utils.dirs.src}/electron.js`);
-   }
-
-   const leanwebJSONPath = `${process.cwd()}/${utils.dirs.src}/leanweb.json`;
-   const project = require(leanwebJSONPath);
-   if (!project.electron) {
-      utils.exec(`npm i -D electron --loglevel=error`);
-      project.electron = true;
-      fs.writeFileSync(leanwebJSONPath, JSON.stringify(project, null, 2));
-   }
-
-   await utils.exec(`npx leanweb clean`);
-   await utils.exec(`npx leanweb build ${env}`);
-
-   fse.copySync(`./${utils.dirs.build}/electron.js`, `./${utils.dirs.electron}/electron.js`);
-   fse.copySync(`./${utils.dirs.build}/index.html`, `./${utils.dirs.electron}/index.html`);
-   fse.copySync(`./${utils.dirs.build}/${project.name}.css`, `./${utils.dirs.electron}/${project.name}.css`);
-   fse.copySync(`./${utils.dirs.build}/favicon.svg`, `./${utils.dirs.electron}/favicon.svg`);
-   project.resources?.forEach(resource => {
-      const source = `./${utils.dirs.build}/${resource}`;
-      if (fs.existsSync(source)) {
-         fse.copySync(source, `./${utils.dirs.electron}/${resource}`, { dereference: true });
-      }
-   });
-
-   const webpackConfig = utils.getWebPackConfig(utils.dirs.electron, project);
-
-   const compiler = webpack({
-      ...webpackConfig,
-      mode: 'development',
-      devtool: 'eval-cheap-module-source-map',
-      performance: {
-         hints: false,
-      },
-   });
-
-   compiler.run(async (err, stats) => {
-      if (err) {
-         console.log(err);
-      }
-      if (stats.compilation.errors.length) {
-         console.log(stats.compilation.errors);
-      }
-      if (stats.compilation.warnings.length) {
-         console.log(stats.compilation.warnings);
-      }
-      await utils.exec(`npx electron ${process.cwd()}/${utils.dirs.electron}/electron.js`);
-   });
-})();

package/templates/electron.js

@@ -1,43 +0,0 @@
-import { app, BrowserWindow } from 'electron';
-
-const createWindow = () => {
-   // Create the browser window.
-   const win = new BrowserWindow({
-      width: 640,
-      height: 480,
-      webPreferences: {
-         nodeIntegration: true
-      }
-   });
-
-   // and load the index.html of the app.
-   win.loadFile('index.html');
-
-   // Open the DevTools.
-   // win.webContents.openDevTools();
-};
-
-// This method will be called when Electron has finished
-// initialization and is ready to create browser windows.
-// Some APIs can only be used after this event occurs.
-app.whenReady().then(createWindow);
-
-// Quit when all windows are closed.
-app.on('window-all-closed', () => {
-   // On macOS it is common for applications and their menu bar
-   // to stay active until the user quits explicitly with Cmd + Q
-   if (process.platform !== 'darwin') {
-      app.quit();
-   }
-});
-
-app.on('activate', () => {
-   // On macOS it's common to re-create a window in the app when the
-   // dock icon is clicked and there are no other windows open.
-   if (BrowserWindow.getAllWindows().length === 0) {
-      createWindow();
-   }
-});
-
-// In this file you can include the rest of your app's specific main process
-// code. You can also put them in separate files and require them here.