ziko 0.65.0 → 0.67.0

package/src/hooks/use-event-emitter.d.ts

@@ -0,0 +1,46 @@
+declare class UseEventEmitter {
+    constructor(maxListeners?: number);
+
+    /**
+     * Register and listen for an event.
+     * The listener will be called every time the event is emitted.
+     */
+    on(event: string, listener: (...args: any[]) => void): this;
+
+    /**
+     * Register and listen for an event ONCE.
+     * After the first call, the listener is automatically removed.
+     */
+    once(event: string, listener: (...args: any[]) => void): this;
+
+    /**
+     * Remove a specific listener.
+     */
+    off(event: string, listener: (...args: any[]) => void): this;
+
+    /**
+     * Emit an event and call all listeners associated with it.
+     * Returns true if the event had listeners; otherwise false.
+     */
+    emit(event: string, data?: any): boolean;
+
+    /**
+     * Remove all listeners for a specific event.
+     */
+    remove(event: string): this;
+
+    /**
+     * Clear all events and their listeners.
+     */
+    clear(): this;
+
+    /**
+     * Set the maximum number of listeners allowed per event.
+     */
+    setMaxListeners(max: number): this;
+}
+
+/** Create a new event emitter instance */
+declare const useEventEmitter: (maxListeners?: number) => UseEventEmitter;
+
+export { UseEventEmitter, useEventEmitter };

package/src/hooks/use-favicon.d.ts

@@ -0,0 +1,41 @@
+export declare class UseFavIcon {
+    /**
+     * Create a favicon manager.
+     * @param FavIcon Initial favicon URL.
+     * @param withEmitter Whether to enable an internal event emitter (default: true).
+     */
+    constructor(FavIcon?: string, withEmitter?: boolean);
+
+    /**
+     * Sets the favicon URL.
+     * Emits "ziko:favicon-changed" if emitter is enabled.
+     */
+    setFavicon(href: string): this;
+
+    /**
+     * Returns the current favicon URL.
+     */
+    readonly current: string;
+
+    /**
+     * Listen for favicon changes.
+     * Callback receives the new href as a string.
+     */
+    onChange(callback: (href: string) => void): this;
+
+    /**
+     * To Do 
+     * Disable or remove the internal event emitter entirely.
+     */
+    removeEventEmitter(): this;
+
+    /**
+     * Enable the internal event emitter manually.
+     */
+    useEventEmitter(): this;
+}
+
+/**
+ * Factory function to create a `UseFavIcon` instance.
+ */
+export declare const useFavIcon: (FavIcon?: string, withEmitter?: boolean) => UseFavIcon;

package/src/hooks/use-ipc.d.ts

@@ -0,0 +1,12 @@
+export declare class UseIPC {
+    emit(event: string, data: any, rooms?: string[]): this;
+    on(event: string, handler: (data: any) => void, rooms?: string | string[]): this;
+    off(event: string, handler: (data: any) => void): this;
+    once(event: string, handler: (data: any) => void, rooms?: string | string[]): this;
+    join(...rooms: string[]): this;
+    leave(...rooms: string[]): this;
+    close(): this;
+
+}
+
+export declare const useIPC: (name?: string) => UseIPC;

package/src/hooks/use-media-query.d.ts

@@ -0,0 +1,24 @@
+export interface MediaQueryRule {
+    query: string;
+    callback: () => void;
+}
+
+export class UseMediaQuery {
+    // Private fields (only for type awareness; not accessible)
+    private readonly #mediaQueryRules: MediaQueryRule[];
+    private readonly #fallback: () => void;
+    private #lastCalledCallback: (() => void) | null;
+
+    constructor(
+        mediaQueryRules?: MediaQueryRule[],
+        fallback?: () => void
+    );
+}
+
+/**
+ * Helper function to create a UseMediaQuery instance.
+ */
+export function useMediaQuery(
+    mediaQueryRules?: MediaQueryRule[],
+    fallback?: () => void
+): UseMediaQuery;

package/src/hooks/use-reactive.d.ts

@@ -0,0 +1,14 @@
+import { mapfun, MapfunResult } from "../math/utils/mapfun.d.ts";
+import { useState } from "./use-state.d.ts";
+
+export function useReactive<
+    T
+>(
+    nested_value: T
+): MapfunResult<
+    (n: any) => {
+        get: ReturnType<typeof useState<any>>[0];
+        set: ReturnType<typeof useState<any>>[1];
+    },
+    T
+>;

package/src/hooks/use-root.d.ts

@@ -0,0 +1,15 @@
+export declare class UseRoot<PropMap extends Record<string, string>> {
+    constructor(PropsMap: PropMap, options?: UseRootOptions);
+
+    currentPropsMap: PropMap;
+    namespace: string;
+    ValidateCssProps: boolean;
+
+    /** Dynamically created CSS variable references */
+    [K in keyof PropMap]: string;
+
+    /**
+     * Apply a new set of properties
+     */
+    use(PropsMap: PropMap): this;
+}

package/src/hooks/use-state.d.ts

@@ -0,0 +1,25 @@
+export function useState<T>(
+    initialValue: T
+): [
+    /** getter function */
+    () => {
+        value: T;
+        isStateGetter: () => true;
+        _subscribe: (fn: (value: T) => void) => void;
+    },
+
+    /** setter function */
+    (newValue: T | ((prev: T) => T)) => void,
+
+    /** controller */
+    {
+        pause: () => void;
+        resume: () => void;
+        clear: () => void;
+        force: (newValue: T | ((prev: T) => T)) => void;
+        getSubscribers: () => Set<(value: T) => void>;
+    }
+];
+
+/** check if argument is a state getter */
+export function isStateGetter(arg: any): boolean;

package/src/hooks/use-storage.d.ts

@@ -0,0 +1,47 @@
+// use-storage.d.ts
+
+export declare class UseStorage {
+    constructor(
+        storage: Storage,
+        globalKey: string,
+        initialValue?: Record<string, any>,
+        use_channel?: boolean
+    );
+
+    /** Current stored items */
+    readonly items: Record<string, any>;
+
+    /** Set entire storage */
+    set(data: Record<string, any>): this;
+
+    /** Merge new data into existing storage */
+    add(data: Record<string, any>): this;
+
+    /** Remove keys from storage */
+    remove(...keys: string[]): this;
+
+    /** Get a single key */
+    get(key: string): any;
+
+    /** Clear storage completely */
+    clear(): this;
+
+    /**
+     * Listen for any storage updates.
+     * Callback receives the data passed to the last .set() / .add() / .remove()
+     */
+    onStorageUpdated(callback: (data: Record<string, any>) => void): this;
+}
+
+/** Factory functions */
+export declare const useLocaleStorage: (
+    key: string,
+    initialValue?: Record<string, any>,
+    use_channel?: boolean
+) => UseStorage;
+
+export declare const useSessionStorage: (
+    key: string,
+    initialValue?: Record<string, any>,
+    use_channel?: boolean
+) => UseStorage;

package/src/hooks/use-thread.d.ts

@@ -0,0 +1,33 @@
+// use-thread.d.ts
+
+export declare class UseThread {
+    constructor();
+
+    /**
+     * Call a function inside the worker.
+     * @param func - Function to execute (cannot capture outer scope)
+     * @param callback - Callback receiving (result, error)
+     * @param args - Optional arguments array to pass to the function
+     * @param close - Automatically close the worker after execution (default true)
+     */
+    call<T = any>(
+        func: (...args: any[]) => T,
+        callback: (result: T | null, error: string | null) => void,
+        args?: any[],
+        close?: boolean
+    ): this;
+
+    /** Terminate the worker manually */
+    terminate(): void;
+}
+
+/**
+ * Helper function for single-use worker threads.
+ * Immediately executes the function and returns the UseThread instance.
+ */
+export declare const useThread: <T = any>(
+    func: (...args: any[]) => T,
+    callback: (result: T | null, error: string | null) => void,
+    args?: any[],
+    close?: boolean
+) => UseThread;

package/src/hooks/use-title.d.ts

@@ -0,0 +1,37 @@
+export declare class UseTitle {
+    /**
+     * Create a reactive title manager.
+     * @param title Initial title. Defaults to `document.title`.
+     * @param withEmitter Whether to create an internal event emitter. Default: true.
+     */
+    constructor(title?: string, withEmitter?: boolean);
+
+    /**
+     * Enables the internal event emitter.
+     */
+    useEventEmitter(): this;
+
+    /**
+     * Sets the document title.
+     * Emits "ziko:title-changed" if emitter is enabled.
+     */
+    setTitle(title: string): this;
+
+    /**
+     * Returns the current document title.
+     */
+    readonly current: string;
+
+    /**
+     * Listen for title changes.
+     */
+    onChange(callback: (title: string) => void): this;
+
+    /**
+     * To Do 
+     * Disable or remove the internal event emitter entirely.
+     */
+    removeEventEmitter(): this;
+}
+
+export declare const useTitle: (title?: string, withEmitter?: boolean) => UseTitle;

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './math'
+export type * from './time'
+export type * from './router'
+export type * from './hooks'
+export type * from './data'

package/src/math/complex/index.d.ts

@@ -0,0 +1,54 @@
+export declare class Complex {
+    a: number;
+    b: number;
+
+    constructor(a?: number, b?: number);
+    constructor(c: Complex);
+    constructor(a: 
+        { a: number; b: number } | 
+        { a: number; z: number } | 
+        { a: number; phi: number } | 
+        { b: number; z: number } | 
+        { b: number; phi: number } | 
+        { z: number; phi: number }
+    );
+    constructor();
+
+    isComplex(): true;
+    toString(): string;
+    readonly __mapfun__ : boolean
+    readonly clone: Complex;
+    readonly z: number;
+    readonly phi: number;
+    readonly conj: Complex;
+    readonly inv: Complex;
+    readonly sqrt: Complex;
+    readonly cbrt: Complex;
+    readonly log: Complex;
+    readonly cos: Complex;
+    readonly sin: Complex;
+    readonly tan: Complex;
+    expo: [number, number];
+
+    add(...z: (number | Complex)[]): this;
+    sub(...z: (number | Complex)[]): this;
+    mul(...z: (number | Complex)[]): this;
+    div(...z: (number | Complex)[]): this;
+    pow(n: number): this;
+    nthr(n?: number): Complex;
+
+    static zero(): Complex;
+    static twiddle(K : number, N : number): Complex;
+    static fromPolar(z: number, phi: number): Complex;
+    
+    static add(c: Complex, ...z: (number | Complex)[]): Complex;
+    static sub(c: Complex, ...z: (number | Complex)[]): Complex;
+    static mul(c: Complex, ...z: (number | Complex)[]): Complex;
+    static div(c: Complex, ...z: (number | Complex)[]): Complex;
+    static pow(c: Complex, n: number): Complex;
+}
+
+export declare function complex(a: number, b?: number): Complex;
+export declare function complex(a: Complex): Complex;
+export declare function complex(a: object): Complex;
+export declare function complex(): Complex;

package/src/math/functions/index.d.ts

@@ -0,0 +1,140 @@
+import type { Complex } from "../complex/index.js";
+import type { MapfunResult, Mappable } from "../utils/mapfun.js";
+
+/* -------------------- MapfunWrap -------------------- */
+
+type MapfunWrap<F extends (x: any) => any, A extends Mappable[]> =
+    A["length"] extends 1
+        ? MapfunResult<F, A[0]>
+        : { [K in keyof A]: MapfunResult<F, A[K]> };
+
+
+/* -------------------- mapfun-based simple operators -------------------- */
+
+export declare function abs<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.abs, A>;
+
+export declare function sqrt<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.sqrt, A>;
+
+export declare function e<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.exp, A>;
+
+export declare function ln<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.log, A>;
+
+/* ---- Fixed-based operators ---- */
+
+export declare function cos<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.cos, A>;
+
+export declare function sin<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.sin, A>;
+
+export declare function tan<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.tan, A>;
+
+export declare function sec<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.sec, A>;
+
+export declare function sinc<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.sinc, A>;
+
+export declare function csc<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.csc, A>;
+
+export declare function cot<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.cot, A>;
+
+export declare function acos<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.acos, A>;
+
+export declare function asin<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.asin, A>;
+
+export declare function atan<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.atan, A>;
+
+export declare function acot<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.acot, A>;
+
+export declare function cosh<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.cosh, A>;
+
+export declare function sinh<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.sinh, A>;
+
+export declare function tanh<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.tanh, A>;
+
+export declare function coth<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.coth, A>;
+
+export declare function acosh<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.acosh, A>;
+
+export declare function asinh<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.asinh, A>;
+
+export declare function atanh<A extends Mappable[]>(...x: A):
+    MapfunWrap<Math.atanh, A>;
+
+/* ---- Math wrappers ---- */
+
+export declare function ceil<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.ceil, A>;
+
+export declare function floor<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.floor, A>;
+
+export declare function round<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.round, A>;
+
+export declare function sign<A extends Mappable[]>(...x: A):
+    MapfunWrap<typeof Math.sign, A>;
+
+export declare function sig<A extends Mappable[]>(...x: A):
+    MapfunWrap<(n: number) => number, A>;
+
+export declare function fact<A extends Mappable[]>(...x: A):
+    MapfunWrap<(n: number) => number, A>;
+
+
+/* -------------------- pow -------------------- */
+
+export declare function pow(x: number, n: number): number;
+export declare function pow(x: number, n: Complex): Complex;
+export declare function pow(x: number, n: Mappable): any;
+
+export declare function pow(x: Complex, n: number): Complex;
+export declare function pow(x: Complex, n: Complex): Complex;
+export declare function pow(x: Complex, n: Mappable): any;
+
+export declare function pow(x: Mappable[], n: number): any[];
+export declare function pow(x: Mappable[], n: Mappable[]): any[];
+
+
+/* -------------------- sqrtn -------------------- */
+
+export declare function sqrtn(x: number, n: number): number;
+export declare function sqrtn(x: number, n: Mappable): any;
+
+export declare function sqrtn(x: Complex, n: number): Complex;
+export declare function sqrtn(x: Complex, n: Mappable): any;
+
+export declare function sqrtn(x: Mappable[], n: number): any[];
+export declare function sqrtn(x: Mappable[], n: Mappable[]): any[];
+
+
+/* -------------------- atan2 -------------------- */
+
+export declare function atan2(x: number, y: number, rad?: boolean): number;
+export declare function atan2(x: number, y: Mappable, rad?: boolean): any;
+export declare function atan2(x: Mappable, y: number, rad?: boolean): any;
+export declare function atan2(x: Mappable[], y: Mappable[], rad?: boolean): any[];
+
+
+/* -------------------- hypot -------------------- */
+
+export declare function hypot(...x: number[]): number;
+export declare function hypot(...x: Mappable[]): any;

package/src/math/functions/logic/index.d.ts

@@ -0,0 +1,11 @@
+import type { Complex } from "../../complex/index.d.ts";
+// import type { Matrix } from "../../matrix/index.d.ts";
+import { Matrix } from '../../../../src/math/matrix/index.js'
+
+export declare const not: (x: 0 | 1 | Complex | Matrix) => 0 | 1 | Complex | Matrix;
+export declare const and: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
+export declare const or: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
+export declare const xor: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
+export declare const nand: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
+export declare const nor: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
+export declare const xnor: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;

package/src/math/functions/mapfun/index.d.ts

@@ -0,0 +1,87 @@
+import { Complex } from "../../../src/math/index.js";
+import { Matrix } from "../../../src/math/matrix/index.js";
+
+/**
+ * Objects that behave like primitives for mapfun,
+ * meaning fun(x) is applied directly without recursion.
+ */
+export interface MapfunPrimitiveLike {
+    __mapfun__?: boolean;
+}
+
+export type PrimitiveLike =
+    | number
+    | boolean
+    | string
+    | bigint
+    | undefined
+    | null
+    | { readonly __mapfun__: boolean };
+
+export type Mappable =
+    | number
+    | string
+    | boolean
+    | bigint
+    | undefined
+    | null
+    | Matrix
+    | MapfunPrimitiveLike
+    | any[]
+    | Set<any>
+    | Map<any, any>
+    | object;
+
+/**
+ * mapfun transform rules
+ */
+export type MapfunResult<F extends (x: any) => any, T> =
+    // Objects with __mapfun__ → treat as primitive (call fun(x))
+    // T extends MapfunPrimitiveLike
+    //     ? ReturnType<F> :
+
+    // Matrix → always return Matrix (your JS logic rebuilds a new Matrix)
+    
+    T extends PrimitiveLike 
+        ? ReturnType<F> :
+    // T extends Complex
+    //     ? T :
+    T extends Matrix
+        ? T :
+
+    // Array → deep-map
+    T extends Array<infer U>
+        ? Array<MapfunResult<F, U>> :
+
+    // Set → deep-map
+    T extends Set<infer U>
+        ? Set<MapfunResult<F, U>> :
+
+    // Map → deep-map values
+    T extends Map<infer K, infer V>
+        ? Map<K, MapfunResult<F, V>> :
+
+    // Other objects → recursively map fields
+    T extends object
+        ? { [K in keyof T]: MapfunResult<F, T[K]> } :
+
+    // Primitive
+    ReturnType<F>;
+
+/**
+ * If only one argument → return mapped value
+ * If multiple → return tuple of mapped values
+ */
+type UnwrapSingle<T extends unknown[]> =
+    T extends [infer U] ? U : { [K in keyof T]: T[K] };
+
+/**
+ * mapfun main declaration
+ */
+export declare function mapfun<
+    F extends (x: any) => any,
+    A extends Mappable[]
+>(
+    fun: F,
+    ...values: A
+): UnwrapSingle<{ [K in keyof A]: MapfunResult<F, A[K]> }>;

package/src/math/functions/utils/index.d.ts

@@ -0,0 +1 @@
+export type * from './mapfun'

package/src/math/functions/utils/mapfun.d.ts

@@ -0,0 +1,43 @@
+import type { Matrix } from "../matrix/index.js";
+import type { Complex } from "../complex/index.js";
+
+export type Mappable =
+    | number
+    | string
+    | boolean
+    | bigint
+    | undefined
+    | null
+    | Complex
+    | Matrix
+    | object
+    | any[]
+    | Set<any>
+    | Map<any, any>;
+
+export type MapfunResult<F, T> =
+    T extends Complex ? ReturnType<F> :
+    // T extends Matrix ? Matrix :
+    T extends Array<infer U> ? Array<MapfunResult<F, U>> :
+    T extends Set<infer U> ? Set<MapfunResult<F, U>> :
+    T extends Map<infer K, infer V> ? Map<K, MapfunResult<F, V>> :
+    T extends object ? { [K in keyof T]: MapfunResult<F, T[K]> } :
+    ReturnType<F>;
+
+/**
+ * Helper to unwrap single-element tuple
+ */
+type UnwrapSingle<T extends unknown[]> = T extends [infer U] ? U : { [K in keyof T]: T[K] };
+
+/**
+ * mapfun:
+ * - if multiple values → return tuple
+ * - if single value → return mapped value directly
+ */
+export declare function mapfun<
+    F extends (x: any) => any,
+    A extends Mappable[]
+>(
+    fun: F,
+    ...values: A
+): UnwrapSingle<{ [K in keyof A]: MapfunResult<F, A[K]> }>;

package/src/math/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './math'
+export type * from './time'
+export type * from './router'
+export type * from './hooks'
+export type * from './data'

package/src/time/clocks/clock.d.ts

@@ -0,0 +1,28 @@
+import { Tick } from "./tick.js";
+
+export interface ClockTickEvent {
+    elapsed: number;
+    delta: number;
+}
+
+export declare class Clock extends Tick {
+    elapsed: number;
+    protected _lastTime: number;
+    protected _callbacks: Set<(ev: ClockTickEvent) => void>;
+
+    constructor(tickMs?: number);
+
+    protected _tick(): void;
+
+    onTick(
+        cb: (ev: ClockTickEvent) => void
+    ): () => boolean;
+
+    reset(): void;
+
+    pause(): void;
+
+    resume(): void;
+}
+
+export declare function clock(tickMs?: number): Clock;