valyrian.js 7.2.11 → 8.0.0

package/lib/signals/index.ts

@@ -0,0 +1,98 @@
+import { current, updateVnode, Vnode, VnodeWithDom } from "valyrian.js";
+import { get, set, hasChanged } from "valyrian.js/utils";
+
+const effectStack: Function[] = [];
+
+// eslint-disable-next-line no-unused-vars
+export type Signal<T> = [() => T, (newValue: T | ((current: T) => T)) => void, () => void];
+
+export function createSignal<T>(initialValue: T): Signal<T> {
+  let value = initialValue;
+  const subscribers = new Set<Function>();
+  const vnodesToUpdate = new WeakSet<Vnode>();
+
+  const runSubscribers = () => subscribers.forEach((subscriber) => subscriber());
+
+  const read = () => {
+    const currentEffect = effectStack[effectStack.length - 1];
+    if (currentEffect && !subscribers.has(currentEffect)) {
+      subscribers.add(currentEffect);
+    }
+
+    const currentVnode = current.vnode as VnodeWithDom;
+    if (currentVnode && !vnodesToUpdate.has(currentVnode)) {
+      const subscription = () => {
+        if (!currentVnode.dom) {
+          subscribers.delete(subscription);
+          vnodesToUpdate.delete(currentVnode);
+          return;
+        }
+        updateVnode(currentVnode);
+      };
+
+      subscribers.add(subscription);
+      vnodesToUpdate.add(currentVnode);
+    }
+
+    return value;
+  };
+
+  // eslint-disable-next-line no-unused-vars
+  const write = (newValue: T | ((current: T) => T)) => {
+    // eslint-disable-next-line no-unused-vars
+    const resolvedValue = typeof newValue === "function" ? (newValue as (current: T) => T)(value) : newValue;
+
+    if (current.event && !current.event.defaultPrevented) {
+      current.event.preventDefault();
+    }
+
+    if (!hasChanged(value, resolvedValue)) {
+      return;
+    }
+
+    value = resolvedValue;
+
+    runSubscribers();
+  };
+
+  return [read, write, runSubscribers];
+}
+
+export function createEffect(effect: Function) {
+  const runEffect = () => {
+    try {
+      effectStack.push(runEffect);
+      effect();
+    } finally {
+      effectStack.pop();
+    }
+  };
+
+  runEffect();
+}
+
+// Path is a string with dot notation, e.g:
+// 'a.b.c' === obj.a.b.c
+// 'a.0.c' === obj.a[0].c
+// eslint-disable-next-line no-unused-vars
+export type SignalStore<T> = [() => T, (path: string, newValue: T | ((current: T) => T)) => void];
+
+export function createSignalStore<T>(initialState: T): SignalStore<T> {
+  const [state, , runSubscribers] = createSignal(initialState);
+
+  // eslint-disable-next-line no-unused-vars
+  const setter = (path: string, newValue: T | ((current: T) => T)) => {
+    const current = get(initialState, path);
+    // eslint-disable-next-line no-unused-vars
+    const resolvedValue = typeof newValue === "function" ? (newValue as (current: T) => T)(current) : newValue;
+
+    if (!hasChanged(current, resolvedValue)) {
+      return;
+    }
+
+    set(initialState, path, resolvedValue);
+    runSubscribers();
+  };
+
+  return [state, setter];
+}

package/lib/suspense/index.ts

@@ -0,0 +1,57 @@
+import { ValyrianComponent, Vnode, isVnodeComponent, isPOJOComponent, isComponent, v, Children } from "valyrian.js";
+import { useState } from "valyrian.js/hooks";
+
+export function Suspense(
+  {
+    fallback,
+    error
+  }: // eslint-disable-next-line no-unused-vars
+  { fallback: any | Vnode | ValyrianComponent; error?: (e: Error) => any | Vnode | ValyrianComponent },
+  children: Children
+): ValyrianComponent {
+  const [loadedChildren, setLoadedChildren] = useState(null);
+  const [err, setErr] = useState(null);
+
+  return v(() => {
+    if (err()) {
+      if (error) {
+        return error(err());
+      }
+      return err().message;
+    }
+
+    if (loadedChildren()) {
+      return loadedChildren();
+    }
+
+    Promise.all(
+      children.map((child) => {
+        if (isVnodeComponent(child)) {
+          if (isPOJOComponent(child.tag)) {
+            return child.tag.view.bind(child.tag)(child.props || {}, child.children);
+          }
+
+          return child.tag(child.props || {}, child.children);
+        }
+
+        if (isPOJOComponent(child)) {
+          return child.view.bind(child)({}, []);
+        }
+
+        if (isComponent(child)) {
+          return child({}, []);
+        }
+
+        return child;
+      })
+    )
+      .then((newChildren) => {
+        setLoadedChildren(newChildren);
+      })
+      .catch((e) => {
+        setErr(e);
+      });
+
+    return fallback;
+  }, {}) as unknown as ValyrianComponent;
+}

package/lib/translate/index.ts

@@ -0,0 +1,156 @@
+import { directive, setPropNameReserved, update, VnodeWithDom } from "valyrian.js";
+import { get } from "valyrian.js/utils";
+
+const translations: Record<string, Record<string, any>> = {};
+let lang = "en";
+
+export function t(path: string, params?: Record<string, string>): string {
+  const langDef = translations[lang];
+  const translation = get(langDef, path);
+
+  if (typeof translation !== "string") {
+    // eslint-disable-next-line no-console
+    console.warn(`Translation not found for ${path}`);
+    return path;
+  }
+
+  if (!params) {
+    return translation;
+  }
+
+  return translation.replace(/{(\w+)}/g, (_, key) => {
+    if (key in params) {
+      return params[key];
+    }
+    return `{${key}}`;
+  });
+}
+
+export function setTranslations(
+  defaultTranslation: Record<string, any>,
+  newTranslations: Record<string, Record<string, any>> = {}
+) {
+  for (const lang in translations) {
+    Reflect.deleteProperty(translations, lang);
+  }
+
+  translations.en = { ...defaultTranslation };
+
+  for (const lang in newTranslations) {
+    translations[lang] = {
+      ...defaultTranslation,
+      ...newTranslations[lang]
+    };
+  }
+  update();
+}
+
+export function getTranslations(): Record<string, Record<string, any>> {
+  return translations;
+}
+
+export function setLang(newLang: string): void {
+  if (typeof newLang !== "string") {
+    throw new Error(`Language ${newLang} not found`);
+  }
+
+  const parsedLang = newLang.toLowerCase().split("-").shift()?.split("_").shift();
+
+  if (typeof parsedLang !== "string") {
+    throw new Error(`Language ${newLang} not found`);
+  }
+
+  if (!translations[parsedLang]) {
+    throw new Error(`Language ${newLang} not found`);
+  }
+
+  lang = parsedLang;
+  update();
+}
+
+export function getLang(): string {
+  return lang;
+}
+
+export class NumberFormatter {
+  #value: number = 0;
+
+  get value(): number {
+    return this.#value;
+  }
+
+  private constructor() {}
+
+  public set(newValue: number | string, shiftDecimal = false) {
+    this.#value = this.clean(newValue, shiftDecimal);
+    return this;
+  }
+
+  private clean(value: string | number, shiftDecimal = false): number {
+    let stringNumber = String(value).replace(/[^0-9.-]+/g, "");
+
+    if (shiftDecimal) {
+      stringNumber = stringNumber.replace(/\./g, "");
+    }
+
+    const number = Number(stringNumber);
+
+    return isNaN(number) ? 0 : number;
+  }
+
+  format(digits = 2, options: Intl.NumberFormatOptions = {}, customLocale?: Intl.LocalesArgument): string {
+    const lang = customLocale || getLang();
+    const formatter = new Intl.NumberFormat(lang as string, {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: digits,
+      maximumFractionDigits: digits,
+      ...options
+    });
+
+    return formatter.format(this.#value);
+  }
+
+  fromDecimalPlaces(decimalPlaces: number) {
+    const currentDecimalPlaces = this.getDecimalPlaces();
+    const factor = Math.pow(10, decimalPlaces - currentDecimalPlaces);
+    this.#value = Number((this.#value / factor).toFixed(decimalPlaces));
+    return this;
+  }
+
+  // Ex toDecimalPlaces(1) = 123.456 -> 12345.6
+  toDecimalPlaces(decimalPlaces: number) {
+    const currentDecimalPlaces = this.getDecimalPlaces();
+    const factor = Math.pow(10, currentDecimalPlaces - decimalPlaces);
+    this.#value = Number((this.#value * factor).toFixed(decimalPlaces));
+    return this;
+  }
+
+  getDecimalPlaces(): number {
+    if (Math.floor(this.#value) === this.#value) {
+      return 0;
+    }
+
+    const stringValue = String(this.#value);
+    const decimalIndex = stringValue.indexOf(".");
+    return decimalIndex === -1 ? 0 : stringValue.length - decimalIndex - 1;
+  }
+
+  shiftDecimalPlaces() {
+    return this.toDecimalPlaces(0);
+  }
+
+  static create(value: number | string = 0, shiftDecimal = false): NumberFormatter {
+    const formatter = new NumberFormatter();
+    return formatter.set(value, shiftDecimal);
+  }
+}
+
+directive("t", (value: string | null, vnode: VnodeWithDom): void => {
+  const keys = typeof value === "string" ? [value] : vnode.children;
+  const params = vnode.props["v-t-params"] || {};
+  const children = keys.map((key) => (typeof key === "string" && key.trim().length > 1 ? t(key.trim(), params) : key));
+  vnode.children = children;
+});
+
+setPropNameReserved("v-t-params");

package/lib/utils/deep-freeze.ts

@@ -0,0 +1,54 @@
+export function deepFreeze(obj: any): any {
+  if (typeof obj === "object" && obj !== null && !Object.isFrozen(obj)) {
+    if (Array.isArray(obj)) {
+      for (let i = 0, l = obj.length; i < l; i++) {
+        deepFreeze(obj[i]);
+      }
+    } else {
+      const props = Reflect.ownKeys(obj);
+      for (let i = 0, l = props.length; i < l; i++) {
+        deepFreeze(obj[props[i]]);
+      }
+
+      // If the object is an instance of a class (not a plain object or array) we need to freeze the prototype
+      const proto = Object.getPrototypeOf(obj);
+      if (proto && proto !== Object.prototype) {
+        deepFreeze(proto);
+      }
+    }
+    Object.freeze(obj);
+  }
+
+  return obj;
+}
+
+export function deepCloneUnfreeze<T>(obj: T): T {
+  if (typeof obj === "undefined" || obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  // If the object is an instance of a class (not a plain object or array) we need to clone it
+  // This could not work with classes that have required parameters in the constructor
+  if (obj.constructor && obj.constructor !== Object && obj.constructor !== Array) {
+    const clone = Reflect.construct(obj.constructor, []);
+
+    for (const key of Reflect.ownKeys(obj)) {
+      const value = (obj as Record<string | symbol, any>)[key];
+      (clone as Record<string | symbol, any>)[key] = deepCloneUnfreeze(value);
+    }
+
+    return clone;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepCloneUnfreeze(item)) as unknown as T;
+  }
+
+  const clone = {} as T;
+  for (const key of Reflect.ownKeys(obj)) {
+    const value = (obj as Record<string | symbol, any>)[key];
+    (clone as Record<string | symbol, any>)[key] = deepCloneUnfreeze(value);
+  }
+
+  return clone;
+}

package/lib/utils/getter-setter.ts

@@ -0,0 +1,40 @@
+// Dot notation: get(obj, 'a.b.c' ) === obj.a.b.c
+// get(obj, 'a.0.c') === obj.a[0].c
+export function get(obj: unknown, path: string, defaultValue?: unknown) {
+  if (!path || typeof path !== "string" || !obj || typeof obj !== "object") {
+    return defaultValue;
+  }
+
+  const result = path.split(".").reduce((acc: any, part) => acc && acc?.[part], obj);
+
+  if (typeof result === "undefined") {
+    return defaultValue || null;
+  }
+
+  return result;
+}
+
+// Dot notation: set(obj, 'a.b.c', value) === obj.a.b.c = value
+// set(obj, 'a.0.c', value) === obj.a[0].c = value
+export function set(obj: any, path: string, value: any) {
+  if (!path || typeof path !== "string" || !obj || typeof obj !== "object") {
+    return;
+  }
+
+  const parts = path.split(".");
+  const last = parts.pop();
+
+  if (!last) {
+    return;
+  }
+
+  let target = obj;
+  for (const part of parts) {
+    if (!target[part]) {
+      target[part] = {};
+    }
+    target = target[part];
+  }
+
+  target[last] = value;
+}

package/lib/utils/has-changed.ts

@@ -0,0 +1,43 @@
+// Utility function to check if dependencies have changed recursively
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export function hasChanged(prev: any, current: any) {
+  if (Array.isArray(prev)) {
+    if (Array.isArray(current) === false) {
+      return true;
+    }
+
+    if (prev.length !== current.length) {
+      return true;
+    }
+
+    for (let i = 0; i < current.length; i++) {
+      if (hasChanged(prev[i], current[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof prev === "object" && prev !== null) {
+    if (typeof current !== "object" || current === null) {
+      return true;
+    }
+
+    for (const key in current) {
+      if (hasChanged(prev[key], current[key])) {
+        return true;
+      }
+    }
+
+    for (const key in prev) {
+      if (hasChanged(prev[key], current[key])) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  return Object.is(prev, current) === false;
+}

package/lib/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./getter-setter";
+export * from "./has-changed";
+export * from "./deep-freeze";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valyrian.js",
-  "version": "7.2.11",
+  "version": "8.0.0",
   "description": "Lightweight steel to forge PWAs. (Minimal Frontend Framework with server side rendering and other capabilities)",
   "repository": "git@github.com:Masquerade-Circus/valyrian.js.git",
   "author": "Masquerade <christian@masquerade-circus.net>",
@@ -16,15 +16,12 @@
   "types": "dist/**/*.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./lib/index.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
-    "./lib/*": {
-      "import": "./lib/*/index.ts"
-    },
     "./*": {
-      "types": "./dist/*.d.ts",
+      "types": "./lib/*/index.ts",
       "import": "./dist/*/index.mjs",
       "require": "./dist/*/index.js"
     }
@@ -59,70 +56,61 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "dev:source": "NODE_ENV=development nodemon --enable-source-maps -e tsx,ts,json,css -w ./lib -w ./www source.js",
-    "dev:test": "nodemon --enable-source-maps -e mjs,js,ts,json,css,tsx,jsx -w ./lib -w ./test -w ./dist --exec 'mocha --bail --timeout 15000 --slow 0 --require ./register --enable-source-maps \"test/**/*_test.js\"'",
-    "dev:test:nyc": "nodemon --enable-source-maps -w ./test -w ./lib -w ./plugins --exec 'nyc --reporter=text --reporter=lcov mocha --timeout 15000 --slow 0 --require ./register \"test/**/*_test.js\"'",
+    "dev:source": "NODE_ENV=development chokidar './lib/**/*.ts' -c 'bun run source.js'",
+    "dev:test": "bun test --bail --watch",
     "dev:web": "browser-sync start --config 'www/bs-config.js'",
-    "build": "npm run build:source && npm run remark",
-    "build:source": "cross-env NODE_ENV=production node source.js",
-    "test": "cross-env NODE_ENV=development nyc mocha --forbid-only --timeout 15000 --slow 0 --require ./register --enable-source-maps --exit \"test/**/*_test.js\"",
-    "coverage": "nyc report --reporter=lcov",
+    "build": "bun run build:source && bun run remark",
+    "build:source": "cross-env NODE_ENV=production bun run source.js",
+    "test": "cross-env NODE_ENV=development bun test --bail --coverage --coverage-reporter=lcov --coverage-reporter=text",
     "remark": "remark . -o",
-    "commit": "git add . && git-cz",
+    "commit": "git add . && git-cz && git push",
     "release": "release-it --verbose",
     "release-test": "release-it --dry-run --verbose",
-    "bench": "nodemon -e js,ts,json,css,tsx -w ./bench -w ./lib -w ./plugins --exec 'NODE_OPTIONS=--enable-source-maps buffalo-test --require ./register'"
+    "update": "ncu -u && bun install"
   },
   "dependencies": {
-    "clean-css": "^5.3.2",
-    "esbuild": "^0.19.3",
-    "favicons": "^7.1.4",
-    "form-data": "^4.0.0",
-    "purgecss": "^5.0.0",
+    "clean-css": "^5.3.3",
+    "esbuild": "^0.24.0",
+    "favicons": "^7.2.0",
+    "form-data": "^4.0.1",
+    "purgecss": "^7.0.2",
     "remark": "^15.0.1",
-    "terser": "^5.20.0",
-    "ts-node": "^10.9.1",
+    "terser": "^5.37.0",
+    "ts-node": "^10.9.2",
     "tsc-prog": "^2.3.0",
-    "tslib": "^2.6.2",
-    "typescript": "^5.2.2"
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.2"
   },
   "devDependencies": {
-    "@release-it/conventional-changelog": "^7.0.2",
-    "@types/clean-css": "^4.2.7",
-    "@types/node": "^20.7.0",
-    "@types/node-fetch": "^2.6.6",
+    "@release-it/conventional-changelog": "^9.0.3",
+    "@types/clean-css": "^4.2.11",
+    "@types/node": "^22.10.1",
+    "@types/node-fetch": "^2.6.12",
     "@types/sharp": "^0.32.0",
     "@types/source-map": "^0.5.7",
-    "@typescript-eslint/eslint-plugin": "^6.7.3",
-    "@typescript-eslint/parser": "^6.7.3",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
     "buffalo-test": "^2.0.0",
-    "compression": "^1.7.4",
+    "chokidar-cli": "^3.0.0",
+    "compression": "^1.7.5",
     "cross-env": "^7.0.3",
     "cz-conventional-changelog": "^3.3.0",
-    "dayjs": "^1.11.10",
-    "eslint": "^8.50.0",
-    "eslint-plugin-sonarjs": "^0.21.0",
+    "dayjs": "^1.11.13",
+    "eslint": "^9.16.0",
+    "eslint-plugin-sonarjs": "^3.0.1",
     "expect": "^29.7.0",
-    "fastify": "^4.23.2",
+    "fastify": "^5.1.0",
     "gzip-size": "^7.0.0",
-    "mocha": "^10.2.0",
-    "nodemon": "^3.0.1",
-    "nyc": "^15.1.0",
+    "npm-check-updates": "^17.1.11",
     "pirates": "^4.0.6",
-    "release-it": "^16.2.1",
-    "remark-cli": "^11.0.0",
+    "release-it": "^17.10.0",
+    "remark-cli": "^12.0.1",
     "remark-toc": "^9.0.0"
   },
   "overrides": {
     "minimist": "^1.2.8",
     "source-map-support": "^0.5.21"
   },
-  "nyc": {
-    "exclude": [
-      "test",
-      "register.js"
-    ]
-  },
   "remarkConfig": {
     "plugins": [
       "toc"
@@ -203,14 +191,14 @@
     },
     "hooks": {
       "before:init": [
-        "npm run build",
-        "npm run test"
+        "bun run build",
+        "bun run test"
       ],
       "after:bump": [
-        "npm run remark"
+        "bun run remark"
       ],
       "after:@release-it/conventional-changelog": [
-        "npm run remark"
+        "bun run remark"
       ]
     }
   }

package/tsconfig.json

@@ -30,5 +30,5 @@
     }
   },
   "include": ["./lib"],
-  "exclude": ["./dist"]
+  "exclude": ["./dist", "./lib/node/utils/node.sw.js"]
 }

package/dist/dataset/index.d.ts

@@ -1,24 +0,0 @@
-import { VnodeInterface, VnodeWithDom } from "valyrian.js";
-interface DataSetInterface<T> {
-    data: T[];
-    reset: (data: T[]) => void;
-    add: (...data: T[]) => void;
-    update: (index: number, data: T) => void;
-    delete: (index: number) => void;
-}
-interface DataSetHandler<T> {
-    (data: T, index: number): VnodeInterface;
-}
-export declare class DataSet<T> implements DataSetInterface<T> {
-    #private;
-    get data(): T[];
-    set data(data: T[]);
-    constructor(data?: T[], shouldFreeze?: boolean);
-    setVnodeAndHandler(vnode: VnodeWithDom, handler: DataSetHandler<T>): void;
-    reset(data: T[]): void;
-    add(...data: T[]): void;
-    delete(index: number): void;
-    update(index: number, item: Partial<T>): void;
-}
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/dataset/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/dataset/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAwD,MAAM,aAAa,CAAC;AAEjH,UAAU,gBAAgB,CAAC,CAAC;IAC1B,IAAI,EAAE,CAAC,EAAE,CAAC;IAEV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IAE3B,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IAE5B,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAEzC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AACD,UAAU,cAAc,CAAC,CAAC;IAExB,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC;CAC1C;AAoBD,qBAAa,OAAO,CAAC,CAAC,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;;IAQpD,IAAI,IAAI,IAQO,CAAC,EAAE,CAFjB;IAED,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,EAEjB;gBAqBW,IAAI,GAAE,CAAC,EAAO,EAAE,YAAY,UAAO;IAK/C,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC;IAMlE,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE;IA2Cf,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE;IA4BhB,MAAM,CAAC,KAAK,EAAE,MAAM;IAcpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;CAgBvC"}