ziko 0.63.2 → 0.65.0

package/types/index.d.ts

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

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

@@ -1,54 +0,0 @@
-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/types/math/functions/index.d.ts

@@ -1,140 +0,0 @@
-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/types/math/functions/logic/index.d.ts

@@ -1,11 +0,0 @@
-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/types/math/index.d.ts

@@ -1,3 +0,0 @@
-export type * from './functions'
-export type * from './complex'
-export type * from './utils'

package/types/math/mapfun/index.d.ts

@@ -1,87 +0,0 @@
-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/types/math/utils/index.d.ts

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

package/types/math/utils/mapfun.d.ts

@@ -1,43 +0,0 @@
-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/types/time/clocks/clock.d.ts

@@ -1,28 +0,0 @@
-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;

package/types/time/clocks/index.d.ts

@@ -1,3 +0,0 @@
-export type * from './tick.d.ts'
-export type * from './clock.d.ts'
-export type * from './scheduler.d.ts'

package/types/time/clocks/scheduler.d.ts

@@ -1,42 +0,0 @@
-export interface TimeTask {
-    fn: () => Promise<any> | any;
-    delay?: number;
-}
-
-export type ParallelTasks = TimeTask[];
-
-export interface TimeSchedulerOptions {
-    repeat?: number;
-    loop?: boolean;
-}
-
-export declare class TimeScheduler {
-    tasks: (TimeTask | ParallelTasks)[];
-    repeat: number;
-    loop: boolean;
-
-    stopped: boolean;
-    running: boolean;
-
-    onStart: (() => void) | null;
-    onTask: ((fn: () => Promise<any> | any) => void) | null;
-    onEnd: (() => void) | null;
-
-    constructor(
-        tasks?: (TimeTask | ParallelTasks)[],
-        options?: TimeSchedulerOptions
-    );
-
-    run(): Promise<void>;
-
-    stop(): void;
-
-    addTask(task: TimeTask | ParallelTasks): void;
-
-    clearTasks(): void;
-}
-
-export declare function Scheduler(
-    tasks?: (TimeTask | ParallelTasks)[],
-    options?: { repeat?: number | null }
-): TimeScheduler;

package/types/time/clocks/tick.d.ts

@@ -1,26 +0,0 @@
-export declare class Tick {
-    ms: number;
-    fn: (self: Tick) => void;
-    count: number;
-    frame: number;
-    id: ReturnType<typeof setInterval> | null;
-    running: boolean;
-
-    constructor(
-        fn: (self: Tick) => void,
-        ms: number,
-        count?: number,
-        start?: boolean
-    );
-
-    start(): this;
-    stop(): this;
-    isRunning(): boolean;
-}
-
-export declare function tick(
-    fn: (self: Tick) => void,
-    ms: number,
-    count?: number,
-    start?: boolean
-): Tick;

package/types/time/decorators/index.d.ts

@@ -1,9 +0,0 @@
-export declare function debounce<T extends (...args: any[]) => any>(
-    fn: T,
-    delay?: number
-): (...args: Parameters<T>) => void;
-
-export declare function throttle<T extends (...args: any[]) => any>(
-    fn: T,
-    delay: number
-): (...args: Parameters<T>) => void;

package/types/time/delay/index.d.ts

@@ -1,12 +0,0 @@
-export declare const sleep: (ms: number) => Promise<void>;
-
-export interface TimeoutResult {
-    id: ReturnType<typeof setTimeout>;
-    clear: () => void;
-    promise: Promise<void>;
-}
-
-export declare function timeout(
-    ms: number,
-    fn?: () => any
-): TimeoutResult;

package/types/time/ease/index.d.ts

@@ -1,103 +0,0 @@
-declare const linear: (t: number) => number;
-
-// --- Sin ---
-declare const in_sin: (t: number) => number;
-declare const out_sin: (t: number) => number;
-declare const in_out_sin: (t: number) => number;
-
-// --- Quad ---
-declare const in_quad: (t: number) => number;
-declare const out_quad: (t: number) => number;
-declare const in_out_quad: (t: number) => number;
-
-// --- Cubic ---
-declare const in_cubic: (t: number) => number;
-declare const out_cubic: (t: number) => number;
-declare const in_out_cubic: (t: number) => number;
-
-// --- Quart ---
-declare const in_quart: (t: number) => number;
-declare const out_quart: (t: number) => number;
-declare const in_out_quart: (t: number) => number;
-
-// --- Quint ---
-declare const in_quint: (t: number) => number;
-declare const out_quint: (t: number) => number;
-declare const in_out_quint: (t: number) => number;
-
-// --- Expo ---
-declare const in_expo: (t: number) => number;
-declare const out_expo: (t: number) => number;
-declare const in_out_expo: (t: number) => number;
-
-// --- Circ ---
-declare const in_circ: (t: number) => number;
-declare const out_circ: (t: number) => number;
-declare const in_out_circ: (t: number) => number;
-
-// --- Arc ---
-declare const arc: (t: number) => number;
-
-// --- Back ---
-declare const back: (t: number, x?: number) => number;
-
-// --- Elastic ---
-declare const elastic: (t: number) => number;
-
-// --- Back variations ---
-declare const in_back: (t: number, c1?: number, c3?: number) => number;
-declare const out_back: (t: number, c1?: number, c3?: number) => number;
-declare const in_out_back: (t: number, c1?: number, c2?: number) => number;
-
-// --- Elastic variations ---
-declare const in_elastic: (t: number, c4?: number) => number;
-declare const out_elastic: (t: number, c4?: number) => number;
-declare const in_out_elastic: (t: number, c5?: number) => number;
-
-// --- Bounce ---
-declare const in_bounce: (t: number, n1?: number, d1?: number) => number;
-declare const out_bounce: (t: number, n1?: number, d1?: number) => number;
-declare const in_out_bounce: (t: number, n1?: number, d1?: number) => number;
-
-// --- Step & Discret ---
-declare const step: (t: number, steps?: number) => number;
-declare const discret: (t: number, segments?: number) => number;
-
-export {
-    linear,
-    in_sin,
-    out_sin,
-    in_out_sin,
-    in_quad,
-    out_quad,
-    in_out_quad,
-    in_cubic,
-    out_cubic,
-    in_out_cubic,
-    in_quart,
-    out_quart,
-    in_out_quart,
-    in_quint,
-    out_quint,
-    in_out_quint,
-    in_expo,
-    out_expo,
-    in_out_expo,
-    in_circ,
-    out_circ,
-    in_out_circ,
-    arc,
-    back,
-    elastic,
-    in_back,
-    out_back,
-    in_out_back,
-    in_elastic,
-    out_elastic,
-    in_out_elastic,
-    in_bounce,
-    out_bounce,
-    in_out_bounce,
-    step,
-    discret
-};

package/types/time/index.d.ts

@@ -1,4 +0,0 @@
-export type * from './ease/index.d.ts'
-export type * from './clocks/index.d.ts'
-export type * from './decorators/index.d.ts'
-export type * from './loop/index.d.ts'

package/types/time/loop/index.d.ts

@@ -1,50 +0,0 @@
-export declare class TimeLoop {
-    callback: (self: TimeLoop) => void;
-
-    protected cache: {
-        isRunning: boolean;
-        id: ReturnType<typeof setTimeout> | null;
-        last_tick: number | null;
-        step: number;
-        t0: number;
-        t1: number;
-        autoplay: boolean;
-        pauseTime: number | null;
-        frame: number;
-        elapsed?: number;
-    };
-
-    constructor(
-        callback: (self: TimeLoop) => void,
-        options?: {
-            step?: number;
-            t0?: number;
-            t1?: number;
-            autoplay?: boolean;
-        }
-    );
-
-    get frame(): number;
-
-    get elapsed(): number | undefined;
-
-    start(): this;
-    pause(): this;
-    resume(): this;
-    stop(): this;
-
-    startAfter(t?: number): this;
-    stopAfter(t?: number): this;
-
-    protected animate: () => void;
-}
-
-export declare function loop(
-    callback: (self: TimeLoop) => void,
-    options?: {
-        step?: number;
-        t0?: number;
-        t1?: number;
-        autoplay?: boolean;
-    }
-): TimeLoop;