ziko 0.49.5 → 0.49.7

package/types/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/types/hooks/use-derived.d.ts

@@ -0,0 +1,14 @@
+export function useDerived<T>(
+    deriveFn: (...values: any[]) => T,
+    sources: Array<
+        () => {
+            value: any;
+            isStateGetter: () => true;
+            _subscribe: (fn: (value: any) => void) => void;
+        }
+    >
+): () => {
+    value: T;
+    isStateGetter: () => true;
+    _subscribe: (fn: (value: T) => void) => void;
+};

package/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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;