@runium/core 0.0.7 → 0.0.9

package/.eslintrc.json

@@ -0,0 +1,30 @@
+{
+  "env": {
+    "node": true,
+    "es2022": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2022,
+    "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint", "prettier"],
+  "rules": {
+    "prettier/prettier": "error",
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        "argsIgnorePattern": "^_",
+        "varsIgnorePattern": "^_"
+      }
+    ],
+    "@typescript-eslint/no-explicit-any": "warn",
+    "no-console": "warn"
+  },
+  "ignorePatterns": ["dist/", "node_modules/"]
+}

package/.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "endOfLine": "lf",
+  "arrowParens": "avoid"
+}

package/README.md

@@ -0,0 +1 @@
+# @runium/core

package/package.json

@@ -1,23 +1,35 @@
 {
   "name": "@runium/core",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Runium Core",
   "author": "TheBeastApp",
   "license": "MIT",
   "type": "module",
-  "main": "./index.js",
-  "module": "./index.js",
-  "files": [
-    "index.js"
-  ],
-  "exports": {
-    ".": {
-      "import": "./index.js"
-    }
+  "scripts": {
+    "build": "vite build",
+    "lint": "eslint ./src --ext .ts",
+    "lint:fix": "eslint ./src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\""
   },
   "dependencies": {
     "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
     "bcx-expression-evaluator": "^1.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.18.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.5",
+    "rollup-plugin-terser": "^7.0.2",
+    "terser": "^5.44.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
+    "vite": "^7.1.12",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-externalize-deps": "^0.10.0"
   }
-}
+}

package/src/error.ts

@@ -0,0 +1,22 @@
+/**
+ * Runium error class
+ */
+export class RuniumError extends Error {
+  code: string;
+
+  payload: unknown;
+
+  constructor(message: string, code: string, payload: unknown = null) {
+    super(message);
+    this.code = code;
+    this.payload = payload;
+  }
+}
+
+/**
+ * Checks if the given error is a RuniumError
+ * @param error
+ */
+export function isRuniumError(error: unknown): boolean {
+  return !!error && error instanceof RuniumError;
+}

package/src/file.ts

@@ -0,0 +1,53 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { RuniumError } from './error';
+
+export type JSONValue = string | number | boolean | JSONObject | JSONValue[];
+
+export interface JSONObject {
+  [x: string]: JSONValue;
+}
+
+/**
+ * File error codes
+ */
+export enum FileErrorCode {
+  READ_JSON = 'file-read-json',
+  WRITE_JSON = 'file-write-json',
+}
+
+/**
+ * Reads a JSON file
+ * @param path
+ */
+export async function readJsonFile<T = JSONValue>(path: string): Promise<T> {
+  try {
+    const data = await readFile(path, { encoding: 'utf-8' });
+    return JSON.parse(data);
+  } catch (ex) {
+    throw new RuniumError(
+      `Can not read JSON file ${path}`,
+      FileErrorCode.READ_JSON,
+      { path, original: ex }
+    );
+  }
+}
+
+/**
+ * Writes a JSON file
+ * @param path
+ * @param data
+ */
+export async function writeJsonFile<T = JSONValue>(
+  path: string,
+  data: T
+): Promise<void> {
+  try {
+    await writeFile(path, JSON.stringify(data, null, 2), { encoding: 'utf-8' });
+  } catch (ex) {
+    throw new RuniumError(
+      `Can not write JSON file ${path}`,
+      FileErrorCode.WRITE_JSON,
+      { path, data, original: ex }
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './error';
+export * from './file';
+export * from './macros';
+export * from './project';
+export * from './project-config';
+export * from './project-schema';
+export * from './task';
+export * from './trigger';

package/src/macros.ts

@@ -0,0 +1,91 @@
+import { RuniumError } from './error';
+
+export type Macro = (...params: string[]) => string;
+
+export type MacrosCollection = Record<string, Macro>;
+
+const UNWRAP_MACROS_PATTERN = String.raw`"\$unwrap\((.*)\)"`;
+
+export enum MacrosErrorCode {
+  MACRO_APPLY_ERROR = 'macro-apply-error',
+}
+
+/**
+ * Apply unwrap macro
+ * @param value
+ */
+function unwrap(value: string): string {
+  const unwrapRegex = new RegExp(UNWRAP_MACROS_PATTERN, 'g');
+
+  return value.replace(unwrapRegex, (match: string, value: string) => {
+    return value.trim();
+  });
+}
+
+/**
+ * Apply macros to a text
+ * @param text
+ * @param macros
+ */
+export function applyMacros(text: string, macros: MacrosCollection): string {
+  const macrosNames = Object.keys(macros);
+
+  const pattern = String.raw`\$(${macrosNames.join('|')})\(([^()]*(?:\([^()]*\)[^()]*)*)\)`;
+
+  const apply = (data: string): string => {
+    const macrosRegex = new RegExp(pattern, 'g');
+
+    let result = data;
+
+    let hasMacros = true;
+    while (hasMacros) {
+      hasMacros = false;
+      result = result.replace(
+        macrosRegex,
+        (match: string, type: string, args: string) => {
+          hasMacros = true;
+
+          const macroArgs: string[] = [];
+          let depth = 0;
+          let current = '';
+
+          for (const char of args) {
+            if (char === ',' && depth === 0) {
+              macroArgs.push(current.trim());
+              current = '';
+            } else {
+              if (char === '(') {
+                depth++;
+              }
+              if (char === ')') {
+                depth--;
+              }
+              current += char;
+            }
+          }
+          macroArgs.push(current.trim());
+
+          const values = macroArgs.map(arg => {
+            return arg ? apply(arg) : '';
+          });
+          try {
+            return macros[type](...values);
+          } catch (ex) {
+            throw new RuniumError(
+              `Can not apply macro "${type}"`,
+              MacrosErrorCode.MACRO_APPLY_ERROR,
+              { type, args: macroArgs, original: ex }
+            );
+          }
+        }
+      );
+    }
+
+    return result;
+  };
+
+  // process text
+  const processedText = macrosNames.length ? apply(text) : text;
+  // apply unwrap macros
+  return unwrap(processedText);
+}