ziko 1.4.0 → 1.6.0

package/src/dom/components/for/index.js

@@ -0,0 +1,17 @@
+import { Fragment, UIFragment } from "../fragment/index.js";
+
+class UIFor extends UIFragment{
+    constructor({each, fallback, mapFn = () => {}} = {}){
+        super()
+        this.config = {
+            each,
+            fallback,
+            mapFn
+        }
+        this.append(
+            ...this.config.each.map((n,i) => this.config.mapFn(n, i))
+        )
+    }
+}
+
+export const For = ({each, fallback, mapFn} = {}) => new UIFor({each, fallback, mapFn})

package/src/dom/components/index.js

@@ -1,2 +1,3 @@
 export * from './swap/index.js'
-export * from './fragment/index.js'
+export * from './fragment/index.js'
+export * from './for/index.js'

package/src/dom/components/swap/index.js

@@ -12,14 +12,14 @@ export class UISwap extends UIElement {
         };
         
         this.append(...items);
-        this.#setup();
+        this.render();
     }
     get activeItem(){
         return this.items[this.states.activeIndex]
     }
-    #setup() {
+    render() {
         this.items.forEach((n, i) => {
-            // Store initial display style (fallback to empty string or default)
+
             const initialDisplay = n.element?.style?.display || '';
             this.#DISPLAYS_MAP.set(n, initialDisplay);
 

package/src/dom/constructors/UIElement.js

@@ -36,9 +36,16 @@ class UIElement extends UIElementCore{
       ViewListeners,
     );
 
-    if(element)this.init(element, name, type, render)
-  }
-  on(event_name, callback, {details_setter, category = 'global', isCustom = false,preventDefault = false} = {}){
+    if(element)this.init(element, name, type, render);
+  }
+  on(event_name, callback, {details_setter, category = 'global', isCustom = false, preventDefault = false} = {}){
+    if(event_name instanceof Array) event_name.forEach(
+      event => this.on(
+        event, 
+        callback, 
+        {details_setter, category, isCustom, preventDefault}
+      )
+    )
     if(category && !this.exp.events.hasOwnProperty(category)) this.exp.events[category] = new EventController(this, category);
     isCustom && this.exp.events[category].cache.customEvents.add(event_name)
     const EVENT = this.exp.events[category];
@@ -51,11 +58,23 @@ class UIElement extends UIElementCore{
     return this;
   }
   _off(event, category = 'global'){
-    this.exp.events[category].removeListener(event)
+    this.exp.events[category].removeListener(event);
+    return this
   }
   get element(){
     return this.cache.element;
   }
+  get itemsTarget(){
+    return this.cache.itemsTarget; 
+  }
+  get itemsTargetElement(){
+    return this.itemsTarget.element;
+  }
+  setItemsTarget(parent){
+    this.cache.itemsTarget = parent;
+    this.items = parent.items;
+    return this;
+  }
   isInteractive(){
     return this.cache.isInteractive;
   }

package/src/dom/constructors/UIElementCore.js

@@ -24,6 +24,7 @@ class UIElementCore extends UINode{
     else this.target = element?.parentElement;
     Object.assign(this.cache, {
       name,
+      itemsTarget : this,
       isInteractive : false,
       parent:null,
       isBody:false,
@@ -60,7 +61,7 @@ class UIElementCore extends UINode{
   get element(){
     return this.cache.element;
   }
-    [Symbol.iterator]() {
+  [Symbol.iterator](){
     return this.items[Symbol.iterator]();
   }
   maintain() {

package/src/dom/constructors/mixins/dom.js

@@ -1,8 +1,3 @@
-// import { isStateGetter } from "../../../hooks/use-state.js";
-// import { 
-//   is_camelcase,
-//   camel2hyphencase
-//  } from '../../../data/string/index.js';
 import { text } from "../../text/index.js";
 
 export function append(...ele) {
@@ -14,19 +9,30 @@ export function prepend(...ele) {
   return this;
 }
 export function insertAt(index, ...ele) {
-  if (index >= this.element.children.length) this.append(...ele);
-  else
+    const target = this.itemsTarget;
+
+    if (index >= target.items.length) return this.append(...ele);
+
     for (let i = 0; i < ele.length; i++) {
-      if (["number", "string"].includes(typeof ele[i])) ele[i] = text(ele[i]);
-      this.element?.insertBefore(ele[i].element, this.items[index].element);
-      this.items.splice(index, 0, ele[i]);
+        if (["number", "string"].includes(typeof ele[i]))
+            ele[i] = text(ele[i]);
+
+        target.element?.insertBefore(
+            ele[i].element,
+            target.items[index].element
+        );
+
+        target.items.splice(index, 0, ele[i]);
     }
-  return this;
+
+    target.maintain();
+
+    return this;
 }
 export function remove(...ele) {
   const remove = (ele) => {
     if (typeof ele === "number") ele = this.items[ele];
-    if (ele?.isUIElement) this.element?.removeChild(ele.element);
+    if (ele?.isUIElement) this.itemsTarget.element?.removeChild(ele.element);
     this.items = this.items.filter((n) => n !== ele);
   };
   for (let i = 0; i < ele.length; i++) remove(ele[i]);
@@ -37,7 +43,7 @@ export function remove(...ele) {
 }
 export function clear(){
   this?.items?.forEach(n=>n.unmount());
-  this.element.innerHTML = "";
+  this.itemsTarget.element.innerHTML = '';
   return this;
 }
 export function replaceElementWith(new_element){
@@ -49,12 +55,12 @@ export function replaceElementWith(new_element){
 }
 export function after(ui){
   if(ui?.isUIElement) ui=ui.element;
-  this.element?.after(ui)
+  this.itemsTarget.element?.after(ui)
   return this;
 }
 export function before(ui){
   if(ui?.isUIElement) ui=ui.element;
-  this.element?.before(ui)
+  this.itemsTarget.element?.before(ui)
   return this;
 }
 
@@ -62,6 +68,9 @@ export function before(ui){
 
 
 export async function __addItem__(adder, pusher, ...ele) {
+  const itemsTarget_el = this.itemsTarget.element;
+  const itemsTarget = this.itemsTarget
+
   if (this.cache.isFrozzen) {
     console.warn("You can't append new item to frozzen element");
     return this;
@@ -77,22 +86,22 @@ export async function __addItem__(adder, pusher, ...ele) {
             (newValue) => (ele[i].element.textContent = newValue),
             ele[i] 
         );
-        // this.element.appendChild(textNode);
+        // this.itemsTarget.element.appendChild(textNode);
       }
     }
     if (typeof globalThis?.Node === "function" && ele[i] instanceof globalThis?.Node) ele[i] = new this.constructor(ele[i]);
     if (ele[i]?.isUINode) {
         ele[i].cache.parent = this;
-        this.element?.[adder](ele[i].element);
-        ele[i].target = this.element;
-        this.items[pusher](ele[i]);
+        itemsTarget_el?.[adder](ele[i].element);
+        ele[i].target = this.itemsTarget.element;
+        itemsTarget.items[pusher](ele[i]);
     } 
     else if(ele[i] instanceof Promise){
       const UIEle = await ele[i]
       UIEle.cache.parent = this;
-      this.element?.[adder](UIEle.element);
-      UIEle.target = this.element;
-      this.items[pusher](UIEle)
+      itemsTarget_el?.[adder](UIEle.element);
+      UIEle.target = this.itemsTarget.element;
+      itemsTarget.items[pusher](UIEle)
     }
     else if (ele[i] instanceof Object) {
       if (ele[i]?.style) this.style(ele[i]?.style);

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

@@ -1,54 +1,231 @@
+import type { Matrix } from "../matrix/index.js";
+
+/**
+ * Represents a complex number.
+ *
+ * A complex number is represented as:
+ * a + bi
+ */
 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(value:
+        | { 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();
 
+    /**
+     * Used by mapfun to identify complex values.
+     */
+    readonly __mapfun__: boolean;
+
+    /**
+     * Checks whether this value is a Complex instance.
+     */
     isComplex(): true;
+
+    /**
+     * Converts the complex number to a string.
+     */
     toString(): string;
-    readonly __mapfun__ : boolean
-    readonly clone: Complex;
+
+    /**
+     * Serializes the complex number.
+     */
+    serialize(): string;
+
+    /**
+     * Deserializes a serialized complex number.
+     */
+    static deserialize(json: string | object): Complex | TypeError;
+
+    /**
+     * Rounds real and imaginary parts.
+     *
+     * @param n Number of decimal digits.
+     */
+    toFixed(n: number): this;
+
+    /**
+     * Formats real and imaginary parts with precision.
+     *
+     * @param n Number of significant digits.
+     */
+    toPrecision(n: number): this;
+
+    /**
+     * Creates a copy of this complex number.
+     */
+    clone(): Complex;
+
+    /**
+     * Magnitude of the complex number.
+     */
     readonly z: number;
+
+    /**
+     * Phase angle in radians.
+     */
     readonly phi: number;
+
+    /**
+     * Complex conjugate.
+     */
     readonly conj: Complex;
+
+    /**
+     * Multiplicative inverse.
+     */
     readonly inv: Complex;
+
+    /**
+     * Exponential representation [magnitude, phase].
+     */
+    readonly expo: [number, number];
+
+    /**
+     * Adds complex numbers.
+     */
+    add(...c: (number | Complex)[]): this;
+
+    /**
+     * Subtracts complex numbers.
+     */
+    sub(...c: (number | Complex)[]): this;
+
+    /**
+     * Multiplies complex numbers.
+     */
+    mul(...c: (number | Complex)[]): this;
+
+    /**
+     * Divides complex numbers.
+     */
+    div(...c: (number | Complex)[]): this;
+
+    /**
+     * Computes modulo.
+     */
+    modulo(...c: (number | Complex)[]): this;
+
+    /**
+     * Raises the complex number to a power.
+     */
+    pow(...c: (number | Complex)[]): this;
+
+    /**
+     * Calculates the nth root.
+     */
+    nthr(n?: number): Complex;
+
+    /**
+     * Square root.
+     */
     readonly sqrt: Complex;
+
+    /**
+     * Cube root.
+     */
     readonly cbrt: Complex;
+
+    /**
+     * Complex logarithm.
+     */
     readonly log: Complex;
+
+    /**
+     * Complex cosine.
+     */
     readonly cos: Complex;
+
+    /**
+     * Complex sine.
+     */
     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;
+    /**
+     * Complex tangent.
+     */
+    readonly tan: Complex;
 
+    /**
+     * Returns zero 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;
+
+    /**
+     * Creates a complex number from polar coordinates.
+     *
+     * @param z Magnitude.
+     * @param phi Angle in radians.
+     */
+    static fromPolar(
+        z: number,
+        phi: number
+    ): Complex;
+
+    /**
+     * Creates FFT twiddle factor.
+     */
+    static twiddle(
+        K: number,
+        N: number
+    ): Complex;
+
+    /**
+     * Generates random complex numbers.
+     */
+    static readonly random: {
+        int(
+            a?: number,
+            b?: number
+        ): Complex;
+
+        float(
+            a?: number,
+            b?: 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;
+
+/**
+ * Creates a complex number.
+ */
+export declare function complex(
+    a?: number,
+    b?: number
+): Complex;
+
+export declare function complex(
+    a: Complex
+): Complex;
+
+export declare function complex(
+    a: object
+): Complex;
+
+
+/**
+ * Creates arrays of complex numbers from two arrays.
+ */
+export declare function complex(
+    a: number[] | ArrayLike<number>,
+    b: number[] | ArrayLike<number>
+): Complex[];
+
+
+/**
+ * Creates a complex matrix by combining two matrices.
+ */
+export declare function complex(
+    a: Matrix,
+    b: Matrix
+): Matrix;

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

@@ -0,0 +1,95 @@
+/**
+ * Arithmetic operation compatible with numbers,
+ * complex numbers, and matrix-like objects.
+ */
+export type ArithmeticValue = number | ComplexLike | MatrixLike;
+
+/**
+ * Minimal interface for complex number objects.
+ */
+export interface ComplexLike {
+    isComplex(): boolean;
+
+    clone(): this;
+
+    add(value: number | ComplexLike): this;
+    sub(value: number | ComplexLike): this;
+    mul(value: number | ComplexLike): this;
+    div(value: number | ComplexLike): this;
+    modulo(value: number | ComplexLike): this;
+}
+
+/**
+ * Minimal interface for matrix objects.
+ */
+export interface MatrixLike {
+    rows: number;
+    cols: number;
+
+    isMatrix(): boolean;
+
+    clone(): this;
+
+    add(value: ArithmeticValue): this;
+    sub(value: ArithmeticValue): this;
+    mul(value: ArithmeticValue): this;
+    div(value: ArithmeticValue): this;
+    modulo(value: ArithmeticValue): this;
+}
+
+/**
+ * Adds values together.
+ *
+ * Supports numbers, complex numbers, and matrices.
+ *
+ * @example
+ * add(1, 2, 3) // 6
+ */
+export declare function add<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Subtracts values sequentially.
+ *
+ * @example
+ * sub(10, 2, 3) // 5
+ */
+export declare function sub<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Multiplies values sequentially.
+ *
+ * @example
+ * mul(2, 3, 4) // 24
+ */
+export declare function mul<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Divides values sequentially.
+ *
+ * @example
+ * div(20, 2, 5) // 2
+ */
+export declare function div<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Calculates modulo sequentially.
+ *
+ * @example
+ * modulo(20, 6) // 2
+ */
+export declare function modulo<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;

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

@@ -0,0 +1,101 @@
+/**
+ * Converts a value from one numerical base to another.
+ *
+ * Supported bases are between 2 and 36.
+ *
+ * @param value Value to convert.
+ * @param fromBase Source base.
+ * @param toBase Target base.
+ *
+ * @example
+ * base2base("1010", 2, 10) // "10"
+ */
+export declare function base2base(
+    value: string | number,
+    fromBase: number,
+    toBase: number
+): string;
+
+/**
+ * Converts binary values to octal.
+ */
+export declare function bin2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts binary values to decimal.
+ */
+export declare function bin2dec(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts binary values to hexadecimal.
+ */
+export declare function bin2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to binary.
+ */
+export declare function oct2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to decimal.
+ */
+export declare function oct2dec(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to hexadecimal.
+ */
+export declare function oct2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to binary.
+ */
+export declare function dec2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to octal.
+ */
+export declare function dec2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to hexadecimal.
+ */
+export declare function dec2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to binary.
+ */
+export declare function hex2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to octal.
+ */
+export declare function hex2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to decimal.
+ */
+export declare function hex2dec(
+    ...x: (string | number)[]
+): string[];