@makano/rew 1.1.6 → 1.1.8

package/README.md

@@ -12,7 +12,7 @@ Rew
 <a href="https://www.npmjs.com/package/rayous">  <img src="https://img.shields.io/npm/v/@makano/rew?style=for-the-badge&logo=npm&color=b4befe&logoColor=9399b2&labelColor=181825" alt="npm version" /></a>
 </p>
 
-Rayous is a simple lightweight coffeescript runtime, made to simply using coffescript and revive it
+Rew is a simple lightweight coffeescript runtime, made to simply using coffescript and revive it
 in the process.
 
 ## Getting Started

package/build.sh

@@ -3,4 +3,6 @@ opath=./bin/ui
 if [ $1 ]; then
   opath=$1
 fi
-g++ ./cpp/ui.cpp -o $opath `pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.0 libwebsockets jsoncpp`
+# g++ ./cpp/ui.cpp -o $opath `pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.0 libwebsockets jsoncpp`
+meson build
+cd build && ninja && mv ./ui $opath && cd ../ && rm -r ./build

package/lib/rew/cli/cli.js

@@ -8,12 +8,13 @@ const { watch } = require('chokidar');
 const utils = require('./utils');
 const { existsSync, readFileSync, writeFileSync, mkdirSync } = require('fs');
 const { log } = require('./log');
-const { compileFile, compile } = require('../modules/compiler');
+const { compile } = require('../modules/compiler');
+const crypto = require('crypto');
 
 yargs(hideBin(process.argv))
   .command(
-    '$0 <file>', 
-    'Run the specified file', 
+    '$0 <file>',
+    'Run the specified file',
     (yargs) => {
       yargs
         .positional('file', {
@@ -28,36 +29,36 @@ yargs(hideBin(process.argv))
     },
     (argv) => {
       const filePath = path.resolve(process.cwd(), argv.file);
-      if(!existsSync(filePath)){
+      if (!existsSync(filePath)) {
         log('File not found:', argv.file, ':end');
         return;
       }
       const watching = [];
       const watchIt = (file) => {
-        if(watching.includes(file)) return;
+        if (watching.includes(file)) return;
         watch(file).on('change', () => runIt());
         watching.push(file);
       }
       let prevFork;
       const runIt = () => {
-        if(argv.watch) console.clear();
-        if(prevFork && !prevFork.killed) prevFork.kill?.();
+        if (argv.watch) console.clear();
+        if (prevFork && !prevFork.killed) prevFork.kill?.();
         prevFork = fork(path.resolve(__dirname, './run.js'))
-        .on('message', (data) => {
-          if(argv.watch){
-            data.forEach(file => {
-              watchIt(file);
-            });
-          }
-        }).send({ filePath, watch: argv.watch });
-        if(argv.watch) watchIt(filePath);
+          .on('message', (data) => {
+            if (argv.watch) {
+              data.forEach(file => {
+                watchIt(file);
+              });
+            }
+          }).send({ filePath, watch: argv.watch });
+        if (argv.watch) watchIt(filePath);
       }
       runIt();
     }
   )
   .command(
-    'conf <command> [path] [key] [value]', 
-    'Configuration management', 
+    'conf <command> [path] [key] [value]',
+    'Configuration management',
     (yargs) => {
       yargs
         .positional('command', {
@@ -84,51 +85,68 @@ yargs(hideBin(process.argv))
     (argv) => {
       const { command, path, key, value } = argv;
       const result = utils.conf(command, path, key, value);
-      if(result) console.log(result);
+      if (result) console.log(result);
     }
   )
-  .command('create <path>',  'Create a new project', (yargs) => {
+  .command('create <path>', 'Create a new project', (yargs) => {
     yargs
       .positional('path', {
         describe: 'Path of the project to create',
         type: 'string',
       });
-    },
+  },
     (argv) => {
       utils.createProject(argv.path);
     }
   )
-  .command('ui-bin <path>',  'Build the UI bin for your own app', (yargs) => {
+  .command('rune-keygen <secret>', 'Generate a rune encryption key', (yargs) => {
+    yargs.option('secret', {
+      describe: 'Secret used to generate encryption key',
+      type: 'string'
+    });
+  }, (argv) => {
+    const generateEncryptionKey = (secret) => {
+      if (secret) {
+        return crypto.createHash('sha256').update(secret).digest('hex');
+      } else {
+        return crypto.randomBytes(32).toString('hex');
+      }
+    };
+
+    const encryptionKey = generateEncryptionKey(argv.secret);
+    console.log('Encryption Key:', encryptionKey);
+  })
+  .command('ui-bin <path>', 'Build the UI bin for your own app', (yargs) => {
     yargs
       .positional('path', {
         describe: 'Path of the output bin',
         type: 'string',
       });
-    },
+  },
     (argv) => {
-      execSync('sh '+path.resolve(__dirname, '../../../build.sh')+' '+argv.path);
+      execSync('sh ' + path.resolve(__dirname, '../../../build.sh') + ' ' + argv.path);
     }
   )
-  .command('run <path | package>',  'Run an app', (yargs) => {
+  .command('run <path | package>', 'Run an app', (yargs) => {
     yargs
       .positional('path', {
         describe: 'Path of the app to run',
         type: 'string',
       });
-    },
+  },
     (argv) => {
       utils.runApp(argv.path);
     }
   )
-  .command('install <path>',  'Install an app', (yargs) => {
+  .command('install <path>', 'Install an app', (yargs) => {
     yargs
       .positional('path', {
         describe: 'Path of the app to install',
         type: 'string',
       });
-    },
+  },
     async (argv) => {
-      if(argv.path.startsWith('github:')) utils.installApp(await utils.cloneGit(argv.path), true, true);
+      if (argv.path.startsWith('github:')) utils.installApp(await utils.cloneGit(argv.path), true, true);
       else utils.installApp(argv.path);
     }
   )
@@ -161,7 +179,7 @@ yargs(hideBin(process.argv))
 
     function writeCompiledFile(filePath, compiledCode) {
       const dirName = outputDir ? outputDir : path.dirname(filePath);
-      if(!existsSync(dirName)) mkdirSync(dirName, { recursive: true });
+      if (!existsSync(dirName)) mkdirSync(dirName, { recursive: true });
       const baseName = path.basename(filePath, path.extname(filePath));
       const newFilePath = path.join(dirName, `${baseName}.js`);
       writeFileSync(newFilePath, compiledCode, { encoding: 'utf-8' });
@@ -171,20 +189,20 @@ yargs(hideBin(process.argv))
     function processFile(filePath, importsArray) {
       const content = readFile(filePath);
       const imports = extractImports(content);
-  
+
       imports.forEach(importStatement => {
         const importedFilePath = path.resolve(path.dirname(filePath), importStatement.url);
         if (!importsArray.some(importObj => importObj.url === importStatement.url)) {
-          
-          if(existsSync(importedFilePath)){
+
+          if (existsSync(importedFilePath)) {
             importsArray.push(importStatement);
             processFile(importedFilePath, importsArray);
-          } else if(existsSync(importedFilePath+'.coffee')){
+          } else if (existsSync(importedFilePath + '.coffee')) {
             importsArray.push(importStatement);
-            processFile(importedFilePath+'.coffee', importsArray);
-          } else if(existsSync(importedFilePath+'.js')){
+            processFile(importedFilePath + '.coffee', importsArray);
+          } else if (existsSync(importedFilePath + '.js')) {
             importsArray.push(importStatement);
-            processFile(importedFilePath+'.js', importsArray);
+            processFile(importedFilePath + '.js', importsArray);
           }
 
         }

package/lib/rew/cli/utils.js

@@ -82,6 +82,7 @@ module.exports = {
       //   }
       // });
       log('Done.', ':end');
+      rl.close();
     }
     if (!fs.existsSync(projectPath)) {
       rl.question(logget('Package Name: '), (pkg) => {

package/lib/rew/const/config_path.js

@@ -0,0 +1,5 @@
+
+const path = require('path');
+
+const CONFIG_PATH = path.resolve(process.env.HOME, '.config/rew');
+module.exports.CONFIG_PATH = CONFIG_PATH;

package/lib/rew/const/opt.js

@@ -3,7 +3,8 @@ const execOptions = {
   resolveExtensions: [{ext: '.js', options: { type: 'js' }}, '.coffee'],
   nativeRequire: false,
   cwdAlias: '$',
-  jsxPragma: 'createElement'
+  jsxPragma: 'createElement',
+  jsx: false
 }
 
 module.exports.execOptions = execOptions;

package/lib/rew/functions/import.js

@@ -30,6 +30,10 @@ module.exports.imp = function (runPath, context) {
     let exports,
       ispkg = findPackage(filename);
 
+    if(filename.startsWith('@') && context.app){
+      filename = filename.replace('@', context.app.path);
+    } 
+
     let filepath = path.resolve(path.dirname(context.module.filepath), filename);
 
     // console.log(typeof runPath);
@@ -74,7 +78,8 @@ module.exports.imp = function (runPath, context) {
     ).context.module.exports;
 
     if (ispkg) {
-      exports = getPackage(filename)(context);
+      const pkg = getPackage(filename)(context);
+      exports = pkg._onImport ? pkg._onImport() : pkg;
     } else if (foundCache) {
 
     } else if (type == "coffee") {

package/lib/rew/misc/findAppInfo.js

@@ -0,0 +1,16 @@
+const jsYaml = require("js-yaml");
+const { findAppPath } = require("./findAppPath");
+const path = require('path');
+const { readFileSync } = require("fs");
+
+module.exports.findAppInfo = function(filepath){
+  const appPath = findAppPath(path.dirname(filepath));
+  if(appPath){
+    const config = jsYaml.load(readFileSync(path.join(appPath, 'app.yaml')));
+    return {
+      path: appPath,
+      config
+    }
+  }
+  return null;
+}

package/lib/rew/misc/findAppPath.js

@@ -0,0 +1,21 @@
+const path = require('path');  // Import the 'path' module
+const fs = require('fs');  // Import the 'path' module
+
+module.exports.findAppPath = (currentDir = __dirname) => {
+  // Check if app.yaml exists in the current directory
+  const appYamlPath = path.join(currentDir, 'app.yaml');
+  if (fs.existsSync(appYamlPath)) {
+    return currentDir;
+  }
+
+  // If not found, move up a directory level
+  const parentDir = path.dirname(currentDir);
+
+  // Check if we reached the root directory
+  if (parentDir === currentDir) {
+    return null;  // Not found
+  }
+
+  // Recursively call the function on the parent directory
+  return module.exports.findAppPath(parentDir);
+};

package/lib/rew/misc/seededid.js

@@ -0,0 +1,15 @@
+
+
+module.exports.seededID = function (seed) {
+  const charCodes = seed.split('').map(char => char.charCodeAt(0));
+
+  let result = '';
+  let sum = 0;
+
+  for (let i = 0; i < charCodes.length; i++) {
+    sum += charCodes[i];
+    result += String.fromCharCode((charCodes[i] + sum) % 26 + 97);
+  }
+
+  return result.slice(0, 12);
+}

package/lib/rew/modules/compiler.js

@@ -185,7 +185,7 @@ function compileRewStuff(content, options) {
 
 const cpl = (module.exports.compile = function (file, options = {}) {
   let c = compile(compileRewStuff(file.content, options), { ...options, filename: file.path, bare: false, inlineMap: false });
-  if(options.jsx) {
+  if(execOptions.jsx || options.jsx) {
     c = babel.transformSync(c, {
       presets: [[babelReact, { pragma: execOptions.jsxPragma }]],
       plugins: []

package/lib/rew/modules/context.js

@@ -1,12 +1,12 @@
 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 { findAppInfo } = require("../misc/findAppInfo");
 
 let mainFile = "";
 const isMainFile = filepath => filepath == mainFile;
@@ -28,6 +28,7 @@ module.exports.prepareContext = function (
       meta: {},
       assert: options.import ?? {}
     },
+    app: findAppInfo(filepath),
     ...fsLib(filepath),
   };
   if (options.useContext) {

package/lib/rew/pkgs/conf.js

@@ -1,8 +1,8 @@
 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);
@@ -12,6 +12,13 @@ const createPackageRoot = (packageName) => {
 
 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);
 

package/lib/rew/pkgs/modules/ui/classes.js

@@ -96,17 +96,20 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
     }
 
     data(key, value){
+      if(!value) return this.options.data[key];
       this.options.data[key] = value;
       return this.update(); 
     }
 
-    attr(attr){
-      this.options.attr = attr;
+    attr(attr, reset = false){
+      if(reset) this.options.attr = attr;
+      else this.options.attr = { ...this.options.attr, ...attr };
       return this.update();
     }
 
-    style(style){
-      this.options.style = style;
+    style(style, reset = false){
+      if(reset) this.options.style = style;
+      else this.options.style = { ...this.options.style, ...style };
       return this.update();
     }
 

package/lib/rew/pkgs/rune.js

@@ -0,0 +1,376 @@
+const fs = require('fs');
+const { v4: uuidv4 } = require('uuid');
+const path = require('path');
+const msgpack = require('tiny-msgpack');
+const crypto = require('crypto');
+const { CONFIG_PATH } = require('../const/config_path');
+
+const ENCRYPTION_KEY = 'e6ad8b0792b9e0472ea44d1f3adfd1d503182efcce25991b05cc5ef83f307ffc';
+
+
+class Change {
+  constructor(values) {
+    this.values = values;
+  }
+}
+
+class PopChange extends Change { };
+
+class PushChange extends Change { };
+
+const runePush = (...values) => new PushChange(values);
+const runePop = (...values) => new PopChange(values);
+
+
+function makeRef(value, props = '') {
+  if (!value['@rune.id']) return null;
+  const collection = getCollectionFromID(value['@rune.id']);
+  const ref = collection + '.' + value['@rune.id'];
+  return '@rune.ref ' + ref + props;
+}
+
+const eid = (s, diff) => s.split('')
+  .map(i => {
+    let charCode = i.charCodeAt(0) + diff;
+    if (charCode > 122) {
+      charCode -= 26;
+    }
+    return String.fromCharCode(charCode);
+  })
+  .join('');
+
+function generateID(id, collection) {
+  return eid(collection, 5) + '+' + id;
+}
+
+function getCollectionFromID(id) {
+  return eid(id.split('+')[0], -5);
+}
+
+const createDB = (dbName, dirname, encryptionKey) => {
+  const dbDirPath = path.join(dirname, dbName);
+  const mainFilePath = path.join(dbDirPath, 'main.bin');
+  const algorithm = 'aes-256-ctr';
+
+  if (!fs.existsSync(dbDirPath)) {
+    fs.mkdirSync(dbDirPath);
+  }
+
+  const encrypt = (data) => {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(algorithm, Buffer.from(encryptionKey, 'hex'), iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    return Buffer.concat([iv, encrypted]);
+  };
+
+  const decrypt = (data) => {
+    const iv = data.slice(0, 16);
+    const encryptedData = data.slice(16);
+    const decipher = crypto.createDecipheriv(algorithm, Buffer.from(encryptionKey, 'hex'), iv);
+    const decrypted = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+    return decrypted;
+  };
+
+  const serializeData = (data) => {
+    return msgpack.encode(data);
+  };
+
+  const deserializeData = (buffer) => {
+    return msgpack.decode(decrypt(buffer));
+  };
+
+  const readMainData = () => {
+    if (!fs.existsSync(mainFilePath)) {
+      writeMainData({ collections: [], maps: [] });
+    }
+    const buffer = fs.readFileSync(mainFilePath);
+    return deserializeData(buffer);
+  };
+
+  const writeMainData = (data) => {
+    const buffer = encrypt(serializeData(data));
+    fs.writeFileSync(mainFilePath, buffer);
+  };
+
+  const readDataFile = (filePath) => {
+    const buffer = fs.readFileSync(filePath);
+    return deserializeData(buffer);
+  };
+
+  const writeDataFile = (filePath, data) => {
+    const buffer = encrypt(serializeData(data));
+    fs.writeFileSync(filePath, buffer);
+  };
+
+  const collection = (collectionName) => {
+    const collectionFilePath = path.join(dbDirPath, `${collectionName}.col`);
+
+    const create = (record) => {
+      const mainData = readMainData();
+      if (!mainData.collections.includes(collectionName)) {
+        mainData.collections.push(collectionName);
+        writeMainData(mainData);
+      }
+
+      let data = [];
+      if (fs.existsSync(collectionFilePath)) {
+        data = readDataFile(collectionFilePath);
+      }
+      const id = uuidv4();
+      record['@rune.id'] = generateID(id, collectionName);
+      data.push(record);
+      writeDataFile(collectionFilePath, data);
+      return record;
+    };
+
+    const read = (id, evaluate = true) => {
+      if (typeof id == "object" && '@rune.id' in id) id = id['@rune.id'];
+      if (!fs.existsSync(collectionFilePath)) return null;
+      const data = readDataFile(collectionFilePath);
+      const record = data.find(record => record['@rune.id'] === id);
+      if (record) {
+        return evaluateRecord(record);
+      }
+      return null;
+    };
+
+    const evaluateRecord = (record, prevRecord) => {
+      const evaluateValue = (val) => {
+        if (typeof val == "string" && val.startsWith('@rune.ref')) {
+          const ref = val.split('@rune.ref')[1].trim();
+          const refData = findRef(ref, false);
+          if (!refData) {
+            return null;
+          } else {
+            let value = refData;
+            if (refData['@rune.id']) {
+              value = prevRecord && prevRecord['@rune.id'] == refData['@rune.id'] ? prevRecord : evaluateRecord(refData, record);
+            }
+            return value;
+          }
+        }
+        if (Array.isArray(val)) {
+          val = val.map(i => evaluateValue(i));
+        }
+        return val;
+      }
+      for (let i in record) {
+        const val = record[i];
+        record[i] = evaluateValue(val);
+      }
+      return record;
+    }
+
+    const update = (caseRecord, newRecord) => {
+      let id;
+      if (typeof caseRecord === 'string') {
+        id = caseRecord;
+      } else if (typeof caseRecord === 'object') {
+        const data = readDataFile(collectionFilePath);
+        const record = data.find(record => {
+          for (const key in caseRecord) {
+            if (record[key] !== caseRecord[key]) return false;
+          }
+          return true;
+        });
+        if (record) {
+          id = record['@rune.id'];
+        } else {
+          return null; // No matching record found
+        }
+      }
+
+      if (!id) return null;
+
+      const data = readDataFile(collectionFilePath);
+      const index = data.findIndex(record => record['@rune.id'] === id);
+      if (index !== -1) {
+        const oldRecord = data[index];
+        for (const key in newRecord) {
+          const value = newRecord[key];
+          if (value instanceof PushChange) {
+            if (!oldRecord[key] || !Array.isArray(oldRecord[key])) {
+              oldRecord[key] = [];
+            }
+            oldRecord[key].push(...value.values);
+          } else if (value instanceof PopChange) {
+            if (oldRecord[key] && Array.isArray(oldRecord[key])) {
+              value.values.forEach(val => {
+                const index = oldRecord[key].indexOf(val);
+                if (index !== -1) {
+                  oldRecord[key].splice(index, 1);
+                }
+              });
+            }
+          } else {
+            oldRecord[key] = value;
+          }
+        }
+        data[index] = oldRecord;
+        writeDataFile(collectionFilePath, data);
+        return data[index];
+      }
+      return null;
+    };
+
+    const find = (criteria) => {
+      if (typeof criteria == "string") return read(criteria);
+      if (!criteria || typeof criteria !== 'object') return null;
+
+      const data = readDataFile(collectionFilePath);
+      const record = data.find(record => {
+        for (const key in criteria) {
+          if (record[key] !== criteria[key]) return false;
+        }
+        return true;
+      }) || null;
+      if (record) {
+        evaluateRecord();
+      }
+      return null;
+    };
+
+    const remove = (id) => {
+      if ('@rune.id' in id) id = id['@rune.id'];
+      if (!fs.existsSync(collectionFilePath)) return false;
+      let data = readDataFile(collectionFilePath);
+      const index = data.findIndex(record => record['@rune.id'] === id);
+      if (index !== -1) {
+        data.splice(index, 1);
+        writeDataFile(collectionFilePath, data);
+        return true;
+      }
+      return false;
+    };
+
+    const list = () => {
+      if (!fs.existsSync(collectionFilePath)) return [];
+      const data = readDataFile(collectionFilePath);
+      return data.map(rec => evaluateRecord(rec));
+    };
+
+    const map = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const mappedData = data.map(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, mappedData);
+      }
+      return mappedData;
+    };
+
+    const transform = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const transformedData = cb(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, mappedData);
+      }
+      return transformedData;
+    }
+
+    const filter = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const filteredData = data.filter(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, filteredData);
+      }
+      return filteredData;
+    };
+
+    const sort = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const sortedData = data.sort(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, sortedData);
+      }
+      return sortedData;
+    };
+
+    return { create, findRef, read, update, remove, find, map, transform, filter, sort, list };
+  };
+
+  const findRef = (ref, evaluate = true) => {
+    const [name, id, ...rest] = ref.split('.');
+    const col = collection(name);
+    const record = col.read(id, evaluate);
+    if (rest.length === 0) return record;
+    let value = record;
+    for (const prop of rest) {
+      if (typeof value != "object") break;
+      if (!(prop in value)) return null;
+      value = value[prop];
+    }
+    return value;
+  };
+
+  const map = (mapName) => {
+    const mapFilePath = path.join(dbDirPath, `${mapName}.map`);
+
+    const set = (key, value) => {
+      const mainData = readMainData();
+      if (!mainData.maps.includes(mapName)) {
+        mainData.maps.push(mapName);
+        writeMainData(mainData);
+      }
+
+      let data = {};
+      if (fs.existsSync(mapFilePath)) {
+        data = readDataFile(mapFilePath);
+      }
+      data[key] = value;
+      writeDataFile(mapFilePath, data);
+    };
+
+    const get = (key) => {
+      if (!fs.existsSync(mapFilePath)) return null;
+      const data = readDataFile(mapFilePath);
+      return data[key] || null;
+    };
+
+    const remove = (key) => {
+      if (!fs.existsSync(mapFilePath)) return false;
+      const data = readDataFile(mapFilePath);
+      if (data[key]) {
+        delete data[key];
+        writeDataFile(mapFilePath, data);
+        return true;
+      }
+      return false;
+    };
+
+    const transform = (cb, mutate = false) => {
+      const data = readDataFile(mapFilePath);
+      const transformedData = cb(data);
+      if (mutate) {
+        writeDataFile(mapFilePath, transformedData);
+      }
+      return transformedData;
+    };
+
+    const list = () => {
+      if (!fs.existsSync(mapFilePath)) return {};
+      const data = readDataFile(mapFilePath);
+      return data;
+    };
+
+    return { set, get, remove, list, transform };
+  };
+
+  return { collection, findRef, makeRef, map };
+};
+
+module.exports = (context) => ({
+  _onImport() {
+    delete this.createDB;
+    return this;
+  },
+  db(dbname, encryptionKey) {
+    if (!context.app) throw new Error('rune can only be used in apps');
+    const pkg = path.join(CONFIG_PATH, context.app.config.package, 'db');
+    if (!fs.existsSync(pkg)) fs.mkdirSync(pkg, { recursive: true });
+    return createDB(dbname, pkg, encryptionKey || ENCRYPTION_KEY);
+  },
+  makeRef,
+  runePop,
+  runePush,
+  createDB
+});

package/meson.build

@@ -0,0 +1,13 @@
+project('rew', 'cpp',
+  version : '0.1',
+  default_options : ['warning_level=3', 'cpp_std=c++14'])
+
+gtk3 = dependency('gtk+-3.0', method : 'pkg-config')
+webkit2gtk = dependency('webkit2gtk-4.0', method : 'pkg-config')
+libwebsockets = dependency('libwebsockets', method : 'pkg-config')
+jsoncpp = dependency('jsoncpp', method : 'pkg-config')
+
+executable('ui',
+           'cpp/ui.cpp',
+           install : true,
+           dependencies : [gtk3, webkit2gtk, libwebsockets, jsoncpp])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "A simple coffescript runtime",
   "main": "lib/rew/main.js",
   "directories": {
@@ -13,6 +13,7 @@
     "lib/",
     "cpp/",
     "bin/",
+    "meson.build",
     "build.sh",
     "README.md"
   ],
@@ -23,7 +24,11 @@
     "type": "git",
     "url": "git+https://github.com/kevinj045/rew.git"
   },
-  "keywords": [],
+  "keywords": [
+    "coffescript",
+    "rew",
+    "runtime"
+  ],
   "author": "makano",
   "license": "ISC",
   "dependencies": {
@@ -33,6 +38,8 @@
     "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "js-yaml": "^4.1.0",
+    "tiny-msgpack": "^2.2.0",
+    "uuid": "^9.0.1",
     "vm": "^0.1.0",
     "yargs": "^17.7.2"
   },