valyrian.js 8.0.13 → 8.1.0

package/lib/pulses/index.ts

@@ -56,7 +56,11 @@ function createStore<StateType extends State, PulsesType extends Pulses<StateTyp
   initialState: StateType | (() => StateType) | null,
   pulses: PulsesType,
   immutable = false
-): StorePulses<PulsesType> & { state: ProxyState<StateType> } {
+): StorePulses<PulsesType> & {
+  state: ProxyState<StateType>;
+  on: (event: string, callback: Function) => void;
+  off: (event: string, callback: Function) => void;
+} {
   const subscribers = new Set<Function>();
   const domWithVnodesToUpdate = new WeakSet<DomElement>();
 
@@ -160,7 +164,7 @@ function createStore<StateType extends State, PulsesType extends Pulses<StateTyp
       const emptyFlush = async () => {};
 
       try {
-        const pulseResult = pulses[key].apply(this, [currentState, ...args]);
+        const pulseResult = pulses[key].apply(this, [currentState, ...args] as any);
         if (pulseResult instanceof Promise) {
           return pulseResult
             .then((resolvedValue) => {
@@ -190,38 +194,82 @@ function createStore<StateType extends State, PulsesType extends Pulses<StateTyp
 
   syncState(localState);
 
+  const listeners: Record<string, Function[]> = {};
+  const trigger = (event: string, ...args: any[]) => {
+    if (listeners[event]) {
+      listeners[event].forEach((callback) => callback(...args));
+    }
+  };
+
   const pulsesProxy = new Proxy(boundPulses, {
     get: (pulses, prop: string) => {
       if (prop === "state") {
         return proxyState;
       }
+      if (prop === "on") {
+        return (event: string, callback: Function) => {
+          if (!listeners[event]) {
+            listeners[event] = [];
+          }
+          listeners[event].push(callback);
+        };
+      }
+      if (prop === "off") {
+        return (event: string, callback: Function) => {
+          if (listeners[event]) {
+            listeners[event] = listeners[event].filter((cb) => cb !== callback);
+          }
+        };
+      }
       if (!(prop in pulses)) {
         throw new Error(`Pulse '${prop}' does not exist`);
       }
       const pulseMethod = pulses[prop];
 
       if (typeof pulseMethod === "function") {
-        return pulseMethod.bind(pulsesProxy);
+        return (...args: any[]) => {
+          const result = pulseMethod.apply(pulsesProxy, args as any);
+          if (result instanceof Promise) {
+            return result.then((r) => {
+              trigger("pulse", prop, args);
+              return r;
+            });
+          }
+          trigger("pulse", prop, args);
+          return result;
+        };
       }
 
       return pulseMethod;
     }
   });
 
-  return pulsesProxy as StorePulses<PulsesType> & { state: ProxyState<StateType> };
+  return pulsesProxy as StorePulses<PulsesType> & {
+    state: ProxyState<StateType>;
+    on: (event: string, callback: Function) => void;
+    off: (event: string, callback: Function) => void;
+  };
 }
 
 export function createPulseStore<StateType extends State, PulsesType extends Pulses<StateType>>(
   initialState: StateType,
   pulses: PulsesType
-): StorePulses<PulsesType> & { state: ProxyState<StateType> } {
+): StorePulses<PulsesType> & {
+  state: ProxyState<StateType>;
+  on: (event: string, callback: Function) => void;
+  off: (event: string, callback: Function) => void;
+} {
   return createStore(initialState, pulses, true);
 }
 
 export function createMutableStore<StateType extends State, PulsesType extends Pulses<StateType>>(
   initialState: StateType,
   pulses: PulsesType
-): StorePulses<PulsesType> & { state: ProxyState<StateType> } {
+): StorePulses<PulsesType> & {
+  state: ProxyState<StateType>;
+  on: (event: string, callback: Function) => void;
+  off: (event: string, callback: Function) => void;
+} {
   console.warn(
     "Warning: You are working with a mutable state. This can lead to unpredictable behavior. All state changes made outside of a pulse will not trigger a re-render."
   );

package/lib/redux-devtools/index.ts

@@ -0,0 +1,86 @@
+/* eslint-disable no-console */
+import { FluxStore } from "valyrian.js/flux-store";
+
+declare global {
+  interface Window {
+    __REDUX_DEVTOOLS_EXTENSION__: any;
+  }
+}
+
+interface DevToolsOptions {
+  name?: string;
+  [key: string]: any;
+}
+
+function getDevTools() {
+  const isBrowser = typeof window !== "undefined";
+  if (isBrowser && window.__REDUX_DEVTOOLS_EXTENSION__) {
+    return window.__REDUX_DEVTOOLS_EXTENSION__;
+  }
+  return null;
+}
+
+export function connectFluxStore(store: FluxStore, options: DevToolsOptions = {}) {
+  const devTools = getDevTools();
+  if (!devTools) {
+    return;
+  }
+
+  const name = options.name || "FluxStore";
+  const dt = devTools.connect({ name, ...options });
+  dt.init(store.state);
+
+  store.on("commit", (_: any, mutation: string, ...args: any[]) => {
+    dt.send({ type: mutation, payload: args }, store.state);
+  });
+
+  store.on("registerModule", (_: any, namespace: string) => {
+    dt.send({ type: `[Module] Register: ${namespace}` }, store.state);
+  });
+
+  store.on("unregisterModule", (_: any, namespace: string) => {
+    dt.send({ type: `[Module] Unregister: ${namespace}` }, store.state);
+  });
+}
+
+export function connectPulseStore(store: any, options: DevToolsOptions = {}) {
+  const devTools = getDevTools();
+  if (!devTools) {
+    return;
+  }
+
+  const name = options.name || "PulseStore";
+  const dt = devTools.connect({ name, ...options });
+  dt.init(store.state);
+
+  if (store.on) {
+    store.on("pulse", (pulse: string, args: any[]) => {
+      dt.send({ type: pulse, payload: args }, store.state);
+    });
+  }
+}
+
+export function connectPulse(pulse: any, options: DevToolsOptions = {}) {
+  // Pulse is [read, write, runSubscribers]
+  // We can't easily hook into the write function without wrapping it.
+  // But the user asked for "simple" and "using existing apis".
+  // If we want to debug individual pulses, we might need to wrap them.
+
+  const devTools = getDevTools();
+  if (!devTools) {
+    return pulse;
+  }
+
+  const name = options.name || "Pulse";
+  const dt = devTools.connect({ name, ...options });
+  const [read, write, run] = pulse;
+  
+  dt.init(read());
+
+  const newWrite = (newValue: any) => {
+    write(newValue);
+    dt.send({ type: "update", payload: newValue }, read());
+  };
+
+  return [read, newWrite, run];
+}

package/lib/request/index.ts

@@ -68,10 +68,17 @@ function serialize(obj: Record<string, any>, prefix: string = ""): URLSearchPara
 }
 
 function serializeFormData(data: Record<string, any>): FormData {
-  return Object.entries(data).reduce((fd, [key, value]) => {
-    fd.append(key, value);
-    return fd;
-  }, new FormData());
+  const fd = new FormData();
+  Object.entries(data).forEach(([key, value]) => {
+    if (value === null || value === undefined) return; // Ignorar nulos
+
+    if (Array.isArray(value)) {
+      value.forEach((v) => fd.append(key, v));
+    } else {
+      fd.append(key, value);
+    }
+  });
+  return fd;
 }
 
 function parseUrl(url: string, options: RequestOptionsWithUrls) {
@@ -97,6 +104,14 @@ function parseUrl(url: string, options: RequestOptionsWithUrls) {
 
 const defaultOptions: RequestOptions = { allowedMethods: ["get", "post", "put", "patch", "delete", "head", "options"] };
 
+const isNativeBody = (data: any) =>
+  data instanceof FormData ||
+  data instanceof URLSearchParams ||
+  data instanceof Blob ||
+  data instanceof ArrayBuffer ||
+  (typeof DataView !== "undefined" && data instanceof DataView) ||
+  (typeof ReadableStream !== "undefined" && data instanceof ReadableStream);
+
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function Requester(baseUrl = "", options: RequestOptions = defaultOptions) {
   const url = baseUrl.replace(/\/$/gi, "").trim();
@@ -157,12 +172,17 @@ function Requester(baseUrl = "", options: RequestOptions = defaultOptions) {
     }
 
     if (data) {
-      const isJson = /json/gi.test(contentType);
-
       if (innerOptions.method === "GET" && typeof data === "object") {
         finalUrl.search = serialize(data).toString();
-      } else if (innerOptions.method !== "GET") {
-        innerOptions.body = isJson ? JSON.stringify(data) : serializeFormData(data);
+      } else if (isNativeBody(data) || typeof data === "string") {
+        innerOptions.body = data as BodyInit;
+      } else {
+        const isJson = /json/gi.test(contentType);
+        if (isJson) {
+          innerOptions.body = JSON.stringify(data);
+        } else {
+          innerOptions.body = serializeFormData(data);
+        }
       }
     }
 

package/lib/translate/index.ts

@@ -1,11 +1,45 @@
-import { directive, setPropNameReserved, update, VnodeWithDom } from "valyrian.js";
+import { current, directive, setPropNameReserved, update, VnodeWithDom } from "valyrian.js";
 import { get } from "valyrian.js/utils";
 
 const translations: Record<string, Record<string, any>> = {};
-let lang = "en";
+let currentLang = "en";
+
+let storeStrategy = {
+  get: () => currentLang,
+  set: (lang: string) => {
+    currentLang = lang;
+  }
+};
+
+export function setStoreStrategy(strategy: { get: () => string; set: (lang: string) => void }) {
+  storeStrategy = strategy;
+}
+
+export function getLang(): string {
+  return storeStrategy.get();
+}
+
+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`);
+  }
+
+  storeStrategy.set(parsedLang);
+  update();
+}
 
 export function t(path: string, params?: Record<string, string>): string {
-  const langDef = translations[lang];
+  const langDef = translations[getLang()];
   const translation = get(langDef, path);
 
   if (typeof translation !== "string") {
@@ -49,29 +83,6 @@ 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;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valyrian.js",
-  "version": "8.0.13",
+  "version": "8.1.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>",
@@ -70,44 +70,44 @@
   },
   "dependencies": {
     "clean-css": "^5.3.3",
-    "esbuild": "^0.25.11",
+    "esbuild": "^0.27.0",
     "favicons": "^7.2.0",
-    "form-data": "^4.0.4",
+    "form-data": "^4.0.5",
     "purgecss": "^7.0.2",
     "remark": "^15.0.1",
-    "terser": "^5.44.0",
+    "terser": "^5.44.1",
     "ts-node": "^10.9.2",
     "tsc-prog": "^2.3.0",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3"
   },
   "devDependencies": {
-    "@release-it/conventional-changelog": "^10.0.1",
-    "@types/bun": "^1.3.0",
+    "@release-it/conventional-changelog": "^10.0.2",
+    "@types/bun": "^1.3.3",
     "@types/clean-css": "^4.2.11",
-    "@types/node": "^24.8.1",
+    "@types/node": "^24.10.1",
     "@types/node-fetch": "^2.6.13",
     "@types/parse-path": "^7.1.0",
     "@types/sharp": "^0.32.0",
     "@types/source-map": "^0.5.7",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
+    "@typescript-eslint/eslint-plugin": "^8.47.0",
+    "@typescript-eslint/parser": "^8.47.0",
     "buffalo-test": "^2.0.0",
     "chokidar-cli": "^3.0.0",
     "compression": "^1.8.1",
     "cross-env": "^10.1.0",
     "cz-conventional-changelog": "^3.3.0",
-    "dayjs": "^1.11.18",
-    "eslint": "^9.37.0",
+    "dayjs": "^1.11.19",
+    "eslint": "^9.39.1",
     "eslint-plugin-sonarjs": "^3.0.5",
     "expect": "^30.2.0",
-    "fastify": "^5.6.1",
+    "fastify": "^5.6.2",
     "gzip-size": "^7.0.0",
     "pirates": "^4.0.7",
-    "release-it": "^19.0.5",
+    "release-it": "^19.0.6",
     "remark-cli": "^12.0.1",
     "remark-toc": "^9.0.0",
-    "typescript-eslint": "^8.46.1"
+    "typescript-eslint": "^8.47.0"
   },
   "overrides": {
     "minimist": "^1.2.8",

package/dist/lib/node/utils/session-storage.d.ts

@@ -1,22 +0,0 @@
-export declare class SessionStorage {
-    private storage;
-    private limit;
-    private persist;
-    private filePath;
-    private directory;
-    constructor({ persist, filePath }?: {
-        persist?: boolean;
-        filePath?: string;
-    });
-    private getStorageSize;
-    private checkSizeLimit;
-    setItem(key: string | null | undefined, value: string | null | undefined): void;
-    getItem(key: string | null | undefined): string | null;
-    removeItem(key: string | null | undefined): void;
-    clear(): void;
-    get length(): number;
-    key(index: number): string | null;
-    private saveToFile;
-    private loadFromFile;
-}
-//# sourceMappingURL=session-storage.d.ts.map

package/dist/lib/node/utils/session-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-storage.d.ts","sourceRoot":"","sources":["../../../../lib/node/utils/session-storage.ts"],"names":[],"mappings":"AAGA,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAA8B;gBAEnC,EAAE,OAAe,EAAE,QAA+B,EAAE,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO;IAiB/G,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAkB/E,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI;IAUtD,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAUhD,KAAK,IAAI,IAAI;IAMb,IAAI,MAAM,IAAI,MAAM,CAEnB;IAGD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOjC,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,YAAY;CAYrB"}

package/lib/node/utils/session-storage.ts

@@ -1,120 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-export class SessionStorage {
-  private storage: { [key: string]: string };
-  private limit: number;
-  private persist: boolean;
-  private filePath: string;
-  private directory: string = ".session-storage";
-
-  constructor({ persist = false, filePath = "./sessionData.json" }: { persist?: boolean; filePath?: string } = {}) {
-    this.storage = {};
-    this.limit = 5 * 1024 * 1024; // 5MB storage limit
-    this.persist = persist;
-    this.filePath = path.resolve(this.directory, filePath);
-
-    if (this.persist) {
-      if (!fs.existsSync(this.directory)) {
-        fs.mkdirSync(this.directory, { recursive: true });
-      }
-
-      // Load data from file if persistence is enabled
-      this.loadFromFile();
-    }
-  }
-
-  // Calculate total size in bytes of stored data
-  private getStorageSize(): number {
-    return new TextEncoder().encode(JSON.stringify(this.storage)).length;
-  }
-
-  // Check if storage limit is exceeded
-  private checkSizeLimit(): void {
-    const size = this.getStorageSize();
-    if (size > this.limit) {
-      throw new DOMException("Storage limit exceeded", "QuotaExceededError");
-    }
-  }
-
-  // Store value under the specified key
-  setItem(key: string | null | undefined, value: string | null | undefined): void {
-    if (key === null || key === undefined) {
-      throw new TypeError("Failed to execute 'setItem' on 'Storage': 1 argument required, but only 0 present.");
-    }
-
-    if (value === null) {
-      value = "null"; // Convert null to "null"
-    } else if (value === undefined) {
-      value = "undefined"; // Convert undefined to "undefined"
-    }
-
-    this.loadFromFile();
-    this.storage[key] = String(value); // Store as string
-    this.checkSizeLimit(); // Check storage limit
-    this.saveToFile(); // Save to file if persistence is enabled
-  }
-
-  // Retrieve value stored under the specified key
-  getItem(key: string | null | undefined): string | null {
-    if (key === null || key === undefined) {
-      throw new TypeError("Failed to execute 'getItem' on 'Storage': 1 argument required, but only 0 present.");
-    }
-
-    this.loadFromFile();
-    return this.storage[key] || null; // Return null if key doesn't exist
-  }
-
-  // Remove the value under the specified key
-  removeItem(key: string | null | undefined): void {
-    if (key === null || key === undefined) {
-      throw new TypeError("Failed to execute 'removeItem' on 'Storage': 1 argument required, but only 0 present.");
-    }
-    this.loadFromFile();
-    Reflect.deleteProperty(this.storage, key); // Remove key from storage
-    this.saveToFile(); // Save to file if persistence is enabled
-  }
-
-  // Clear all stored values
-  clear(): void {
-    this.storage = {};
-    this.saveToFile(); // Save to file if persistence is enabled
-  }
-
-  // Return the number of stored items
-  get length(): number {
-    return Object.keys(this.storage).length;
-  }
-
-  // Return the key at the specified index
-  key(index: number): string | null {
-    this.loadFromFile();
-    const keys = Object.keys(this.storage);
-    return keys[index] || null;
-  }
-
-  // Save data to a file (only if persistence is enabled)
-  private saveToFile(): void {
-    if (this.persist) {
-      try {
-        fs.writeFileSync(this.filePath, JSON.stringify(this.storage), "utf-8");
-      } catch (error) {
-        throw new Error(`Error saving data to file: ${(error as any).message}`);
-      }
-    }
-  }
-
-  // Load data from a file (only if persistence is enabled)
-  private loadFromFile(): void {
-    if (this.persist) {
-      try {
-        if (fs.existsSync(this.filePath)) {
-          const data = fs.readFileSync(this.filePath, "utf-8");
-          this.storage = JSON.parse(data || "{}");
-        }
-      } catch (error) {
-        throw new Error(`Error loading data from file: ${(error as any).message}`);
-      }
-    }
-  }
-}