snapse 0.0.0-stage → 0.9.0

package/dist/state/common/refCountAndType.d.ts

@@ -0,0 +1,8 @@
+import { StateType } from '../../state/types/types.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare const getStateType: (s: LightState) => StateType;
+export declare const setStateType: (s: LightState, stateType: StateType) => number;
+export declare const getRefCount: (s: LightState) => number;
+export declare const setRefCount: (s: LightState, refCount: number) => number;
+export declare const isPromotedElement: (s: LightState) => boolean;
+export declare const markPromotedElement: (s: LightState) => number;

package/dist/state/common/stateProperty.d.ts

@@ -0,0 +1 @@
+export declare const MAX_ARRAY_SIZE = 8;

package/dist/state/compute.d.ts

@@ -0,0 +1,2 @@
+import { State } from '../state/types/types.js';
+export declare const compute: <T>(computeFunction: () => T) => State<T>;

package/dist/state/state.d.ts

@@ -0,0 +1,39 @@
+import { AnyState, ArrayState, FunctionState, ObjectState, PrimitiveState, State, SubscribeCallback, SubscribeOptions, ValueOfState } from './types/types.js';
+import { LightState } from './stateInternals/LightState.js';
+import { Transform } from '../state/transforms/Transform.js';
+export declare class CircularDependencyError extends Error {
+    constructor();
+}
+export declare const isState: <T = State>(value: unknown) => value is T;
+export declare const isLightState: <T>(value: unknown) => value is LightState<T>;
+export declare const isAnyState: <T>(value: unknown) => value is AnyState<T>;
+export declare const subscribeWith: (state: unknown, createSubscription: (ls: LightState) => [target: LightState, transform: Transform]) => () => void;
+export declare const subscribe: <S>(state: S, callback?: SubscribeCallback<NoInfer<ValueOfState<S>>>, options?: SubscribeOptions) => () => void;
+export declare function findState<T>(name: string | symbol, def?: State<T>): State<T>;
+export declare function findState<S extends ObjectState<unknown> | ArrayState<unknown> | PrimitiveState<unknown> | FunctionState<unknown>>(name: string | symbol, def?: ValueOfState<S>): S;
+export declare const lightState: <T>(value: T) => LightState<T>;
+export type StateCreatorType = {
+    <T>(value: T, name?: PropertyKey): State<T>;
+    <S extends ObjectState<unknown> | ArrayState<unknown> | PrimitiveState<unknown> | FunctionState<unknown>>(value: ValueOfState<S>, name?: PropertyKey): S;
+};
+export declare const state: StateCreatorType;
+export declare const createStateLightState: <T>(value: T) => LightState<T>;
+export type PeekType = {
+    <T>(value: ObjectState<T>): T;
+    <T>(value: PrimitiveState<T>): T;
+    <T>(value: FunctionState<T>): T;
+    <T>(value: ArrayState<T>): T[];
+    <T>(value: State<T>): T;
+    <T>(value: LightState<T>): T;
+    <T>(value: T): T;
+};
+export declare const peek: PeekType;
+export declare const getLightState: <T>(value: T) => LightState | undefined;
+export declare const delightstate: PeekType;
+export declare const destate: PeekType;
+export declare const isInComponent: () => boolean;
+export declare const startCapturingStateCalls: (namedStates?: Record<PropertyKey, State>) => void;
+export declare const stopCapturingStateCalls: () => {
+    namedStates: Record<PropertyKey, PrimitiveState<unknown, unknown>> | undefined;
+    subscriptions: (() => void)[] | undefined;
+};

package/dist/state/stateInternals/LightState.d.ts

@@ -0,0 +1,20 @@
+import { IState } from '../types/types.js';
+import { Transform } from '../transforms/Transform.js';
+export declare class LightState<T = unknown> {
+    v: T;
+    rct: number;
+    ver: number;
+    subs: Transform | Transform[] | Set<Transform> | undefined;
+    srcs: LightState | LightState[] | Set<LightState> | undefined;
+    tf: Transform | undefined;
+    prx: IState | undefined;
+    drt: number;
+    constructor(value: T);
+    get<U>(_target: () => void, prop: PropertyKey, receiver: IState<T>): unknown;
+    set(_target: () => void, prop: PropertyKey, value: unknown): boolean;
+    getPrototypeOf(): object | null;
+    apply(_target: () => void, thisArg: object, argumentsList: unknown[]): unknown;
+    getOwnPropertyDescriptor(_target: () => void, key: PropertyKey): PropertyDescriptor | undefined;
+    deleteProperty(_target: () => void, prop: PropertyKey): boolean;
+    ownKeys(): (string | symbol)[];
+}

package/dist/state/stateInternals/internalFunctions.d.ts

@@ -0,0 +1,13 @@
+import { InternalFunctionMap } from '../../state/types/types.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export { createVersion, refresh, updateValue, upsertProperty } from './stateUpdate.js';
+export declare const orFunction: (source: LightState, value: unknown) => unknown;
+export declare const notFunction: (source: LightState) => boolean;
+export declare const STATE_PRIMITIVE = 0;
+export declare const STATE_ARRAY = 1;
+export declare const STATE_POJO = 2;
+export declare const STATE_FUNCTION = 3;
+export declare const STATE_OBJECT = 4;
+export declare const STATE_DOMOBJECT = 5;
+export declare const STATE_NULLISH_PRIMITIVE = 6;
+export declare const internalFunctions: InternalFunctionMap[];

package/dist/state/stateInternals/notify.d.ts

@@ -0,0 +1,7 @@
+import { State } from '../../state/types/types.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare const registerFlushPendingWork: (fn: () => void) => void;
+export declare const queueFlush: () => number | true;
+export declare const fastFlush: (f: EventListener, e: Event) => void;
+export declare const flush: (s?: State) => void;
+export declare const notify: (target: LightState) => void;

package/dist/state/stateInternals/poison.d.ts

@@ -0,0 +1,4 @@
+export declare const createPoisonedValue: (cause: unknown) => unknown;
+export declare const isPoisoned: (v: unknown) => v is object;
+export declare const throwIfPoisoned: (v: unknown) => void;
+export declare const getPoisonCause: (v: object) => unknown;

package/dist/state/stateInternals/stateUpdate.d.ts

@@ -0,0 +1,9 @@
+import { Version } from '../../state/types/types.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare const createVersion: () => number;
+export declare const peekVersion: () => number;
+export declare const assertWritable: (ls: LightState) => void;
+export declare const promoteMemberToStateLightState: (owner: LightState, container: Record<PropertyKey, unknown>, prop: PropertyKey) => LightState;
+export declare const upsertProperty: (container: Record<PropertyKey, unknown>, key: PropertyKey, subValue: unknown, version: Version, byOwner?: boolean) => boolean | undefined;
+export declare const updateValue: <T>(ls: LightState<T>, v: T, version?: Version, byOwner?: boolean) => boolean;
+export declare const refresh: <T>(ls: LightState<T>) => void | undefined;

package/dist/state/subscribeChanges.d.ts

@@ -0,0 +1,2 @@
+import { ChangeRecord, SubscribeCallback, ValueOfState } from './types/types.js';
+export declare const subscribeChanges: <S>(state: S, callback: SubscribeCallback<ValueOfState<S>, ChangeRecord>) => () => void;

package/dist/state/transforms/CallbackTransform.d.ts

@@ -0,0 +1,13 @@
+import { SubscribeCallback } from '../types/types.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+import { Transform } from './Transform.js';
+export declare class CallbackTransform<T = unknown, U = unknown> extends Transform {
+    srcLs: LightState<T>;
+    prio: number;
+    payload?: U;
+    constructor(source: LightState, callback: SubscribeCallback<T, U>, data?: U, priority?: number);
+    static flush(): void;
+    queue(): void;
+    dequeue(): void;
+    execute(): unknown;
+}

package/dist/state/transforms/ChainFunctionTransform.d.ts

@@ -0,0 +1,8 @@
+import { LightState } from '../../state/stateInternals/LightState.js';
+import { Transform } from './Transform.js';
+export declare class ChainFunctionTransform extends Transform {
+    protected srcLs: LightState;
+    private hookName;
+    constructor(source: LightState, args: unknown[], name: PropertyKey);
+    execute(): unknown;
+}

package/dist/state/transforms/ChangeAggregateTransform.d.ts

@@ -0,0 +1,20 @@
+import { LightState } from '../../state/stateInternals/LightState.js';
+import { ChangeRecord } from '../../state/types/types.js';
+import { Transform } from './Transform.js';
+export declare class ChangeAggregateTransform extends Transform {
+    protected srcLs: LightState;
+    private readonly parent;
+    private pathKey;
+    private readonly changes;
+    private readonly containerChildren;
+    private readonly leafValues;
+    private previousArrayChildren;
+    private seq;
+    flg: number;
+    static forState(ls: LightState): LightState;
+    constructor(source: LightState, parent: ChangeAggregateTransform | undefined, key: string | number, changes: ChangeRecord[], containerChildren: Map<LightState, ChangeAggregateTransform>, leafValues: Map<LightState, unknown>, addChanges?: boolean);
+    private buildPath;
+    drain(): ChangeRecord[];
+    execute(addChanges?: boolean): void;
+    handleArrayMutation(currentChildren: LightState[], addChanges: boolean): void;
+}

package/dist/state/transforms/ChangeCallbackTransform.d.ts

@@ -0,0 +1,5 @@
+import { ChangeRecord } from '../../state/types/types.js';
+import { CallbackTransform } from './CallbackTransform.js';
+export declare class ChangeCallbackTransform<T = unknown> extends CallbackTransform<T, ChangeRecord> {
+    execute(): void;
+}

package/dist/state/transforms/ComputeTransform.d.ts

@@ -0,0 +1,4 @@
+import { Transform } from './Transform.js';
+export declare class ComputeTransform<T = unknown> extends Transform {
+    constructor(computeFunction: () => T);
+}

package/dist/state/transforms/DOMRootTransform.d.ts

@@ -0,0 +1,8 @@
+import { Transform } from './Transform.js';
+import { RootController } from '../../DOM/nodeControllers/RootController.js';
+export declare class DOMRootTransform extends Transform {
+    private readonly rootCtl;
+    constructor(root: RootController);
+    queue(): void;
+    execute(): void;
+}

package/dist/state/transforms/FunctionTransform.d.ts

@@ -0,0 +1,5 @@
+import { Transform } from './Transform.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare class FunctionTransform<T extends unknown[] = unknown[]> extends Transform {
+    constructor(source?: LightState, hookFunction?: (...args: T) => unknown, args?: T);
+}

package/dist/state/transforms/IsTransform.d.ts

@@ -0,0 +1,25 @@
+import { Transform } from './Transform.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare class IsTransform extends Transform {
+    protected srcLs: LightState;
+    private compared;
+    private sourceToKey;
+    private oldReference;
+    private sourceRefCount;
+    private queued;
+    private static instances;
+    static for(reference: LightState): IsTransform;
+    constructor(reference: LightState);
+    refreshTarget(target: LightState): void;
+    private rekeyCompared;
+    execute(): void;
+    updateComparedState(ls: LightState, reference: unknown): void;
+    popComparedState(ls: LightState): LightState<unknown>;
+    private removeCompared;
+    queue(target?: LightState): void;
+    private isOwnTarget;
+    subTo(ls: LightState): void;
+    uns(state: LightState): void;
+    addCompared(comparedValue: unknown, target: LightState, comparedState?: LightState): void;
+    new(compared: unknown): import('../types/stateTypes.ts').ObjectState<LightState<boolean>, LightState<boolean>>;
+}

package/dist/state/transforms/LightStateFunctionTransform.d.ts

@@ -0,0 +1,3 @@
+import { FunctionTransform } from './FunctionTransform.js';
+export declare class LightStateFunctionTransform<T extends unknown[] = unknown[]> extends FunctionTransform<T> {
+}

package/dist/state/transforms/MapArrayTransform.d.ts

@@ -0,0 +1,10 @@
+import { State } from '../types/types.js';
+import { Transform } from './Transform.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare class MapArrayTransform extends Transform {
+    protected srcLs: LightState<Array<unknown>>;
+    private previousElements?;
+    private previousIndexStates?;
+    execute(): State;
+    private mapElement;
+}

package/dist/state/transforms/MapValueTransform.d.ts

@@ -0,0 +1,3 @@
+import { LightStateFunctionTransform } from './LightStateFunctionTransform.js';
+export declare class MapValueTransform<T extends unknown[] = unknown[]> extends LightStateFunctionTransform<T> {
+}

package/dist/state/transforms/OptTransform.d.ts

@@ -0,0 +1,10 @@
+import { OptOption } from '../types/types.js';
+import { Transform } from './Transform.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare class OptTransform<T = unknown> extends Transform {
+    protected srcLs: LightState;
+    private opt;
+    private def?;
+    constructor(selector: LightState, options: OptOption<T>, def?: unknown);
+    execute(): import('../types/types.js').AnyState<unknown>;
+}

package/dist/state/transforms/PromiseTransform.d.ts

@@ -0,0 +1,6 @@
+import { Transform } from './Transform.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare class PromiseTransform<T = unknown> extends Transform {
+    constructor(promise: Promise<T>);
+    execute(): LightState<unknown> | undefined;
+}

package/dist/state/transforms/SubscribeTransform.d.ts

@@ -0,0 +1,13 @@
+import { Transform } from './Transform.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare const getSubState: (owner: LightState, prop: PropertyKey) => LightState | undefined;
+export declare class SubscribeTransform extends Transform {
+    protected srcLs: LightState;
+    private static instances;
+    private pendingSelf;
+    private seq;
+    static for(ls: LightState): LightState | undefined;
+    private constructor();
+    queue(target?: LightState): void;
+    execute(): void;
+}

package/dist/state/transforms/Transform.d.ts

@@ -0,0 +1,35 @@
+import { AnyState, State } from '../types/types.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+export declare const queueRoot: (transform: Transform) => void;
+export declare const acquireSet: () => Set<LightState>;
+export declare const releaseSet: (s: Set<LightState>) => void;
+export declare const TRANSFORM_FLAG_CREATE_LIGHT_STATE = 1;
+export declare const TRANSFORM_FLAG_REBUILDS_CHILDREN = 2;
+export declare const nextRunId: () => number;
+export declare const currentRunId: () => number;
+export declare class Transform {
+    protected tgt?: LightState;
+    protected srcLs?: LightState;
+    flg: number;
+    runId: number;
+    protected hookFunction?: (...args: unknown[]) => unknown;
+    protected hookArgs?: unknown[];
+    constructor(source?: LightState, hook?: (...args: unknown[]) => unknown);
+    private static isDirty;
+    private static sourceIsDirty;
+    static throwDelayed(e: unknown): void;
+    static flush(): void;
+    queue(_target?: LightState): void;
+    dequeue(): void;
+    subTo(state: LightState): void;
+    subscribeSources(state: LightState): void;
+    uns(state: LightState): void;
+    unsubscribeSources(state: LightState): void;
+    rfr(): void;
+    execute(): unknown;
+    private hasOnlyPassthroughSource;
+    protected updateTarget<T>(newValue: T | State<T>, newSources: Set<LightState>): AnyState<T>;
+    static connect(target: LightState): void;
+}
+export declare const connectTouchedState: (target: LightState) => void;
+export declare const DERIVED_MEMBER: Transform;

package/dist/state/transforms/transforms.d.ts

@@ -0,0 +1,30 @@
+import { Transform } from './Transform.js';
+import { ChainFunctionTransform } from './ChainFunctionTransform.js';
+import { MapArrayTransform } from './MapArrayTransform.js';
+import { CallbackTransform } from './CallbackTransform.js';
+import { OptTransform } from './OptTransform.js';
+import { ComputeTransform } from './ComputeTransform.js';
+import { LightStateFunctionTransform } from './LightStateFunctionTransform.js';
+import { FunctionTransform } from './FunctionTransform.js';
+import { IsTransform } from './IsTransform.js';
+import { PromiseTransform } from './PromiseTransform.js';
+import { SubscribeTransform } from './SubscribeTransform.js';
+import { DOMRootTransform } from './DOMRootTransform.js';
+import { MapValueTransform } from './MapValueTransform.js';
+type Transforms = {
+    Transform: typeof Transform;
+    ChainFunctionTransform: typeof ChainFunctionTransform;
+    MapArrayTransform: typeof MapArrayTransform;
+    MapValueTransform: typeof MapValueTransform;
+    CallbackTransform: typeof CallbackTransform;
+    OptTransform: typeof OptTransform;
+    ComputeTransform: typeof ComputeTransform;
+    LightStateFunctionTransform: typeof LightStateFunctionTransform;
+    IsTransform: typeof IsTransform;
+    PromiseTransform: typeof PromiseTransform;
+    FunctionTransform: typeof FunctionTransform;
+    SubscribeTransform: typeof SubscribeTransform;
+    DOMRootTransform: typeof DOMRootTransform;
+};
+export declare const transforms: Transforms;
+export {};

package/dist/state/types/stateTypes.d.ts

@@ -0,0 +1,175 @@
+import { NodeController } from '../../DOM/nodeControllers/NodeController.js';
+type Nullish = null | undefined;
+declare const STATE_BRAND: unique symbol;
+type StateBrand = {
+    readonly [STATE_BRAND]: true;
+};
+export type SomeState = StateBrand;
+declare const STATE_VALUE: unique symbol;
+export type ObjectStateOf<V> = {
+    [STATE_VALUE]?(value: V): void;
+} & StateBrand;
+export type OrType<T = unknown> = <U>(v: U) => State<T | U>;
+export type CatchType<Full = unknown> = (v: unknown) => State<Full>;
+export type MaybeState<T> = T | State<T>;
+type ArrayStateConstraint<T> = {
+    push(...items: T[]): unknown;
+    set: unknown;
+};
+export type ValueOfState<S> = S extends FunctionState<infer T> ? T : S extends ArrayState<infer T> ? T[] : S extends ObjectState<infer T> ? T : S extends PrimitiveState<infer T> ? T : S extends PrimitiveStateMethods<infer T> ? T : S;
+type OptKey<Self> = [Extract<Self, PropertyKey>] extends [never] ? string : Extract<Self, PropertyKey>;
+type OptFullMap<Self> = Record<OptKey<Self>, unknown>;
+type OptPartialMap<Self> = Partial<Record<OptKey<Self>, unknown>>;
+type NotOptMap<Self, T> = T extends OptPartialMap<Self> ? never : T;
+export interface OptType<Self = unknown> {
+    <T, U = T>(options: ArrayStateConstraint<T>, def: U | State<U>): NoInfer<State<T | U>>;
+    <T>(options: ArrayStateConstraint<T>): NoInfer<State<T | undefined>>;
+    <T extends OptFullMap<Self>>(options: T): NoInfer<State<T[keyof T] | undefined>>;
+    <T extends OptFullMap<Self>>(options: State<T>): NoInfer<State<T[keyof T] | undefined>>;
+    <T extends OptPartialMap<Self>, U = T[keyof T]>(options: T, def: U | State<U>): NoInfer<State<T[keyof T] | U>>;
+    <T extends OptPartialMap<Self>, U = T[keyof T]>(options: State<T>, def: U | State<U>): NoInfer<State<T[keyof T] | U>>;
+    <T, U = T>(options: T[] | State<T[]>, def: U | State<U>): NoInfer<State<T | U>>;
+    <T>(options: T[] | State<T[]>): NoInfer<State<T | undefined>>;
+    <T, D>(options: NotOptMap<Self, T>, def: D): NoInfer<State<T | ValueOfState<D>>>;
+    <T>(options: NotOptMap<Self, T>): NoInfer<State<T | undefined>>;
+}
+type StringState = {
+    at(index: number): State<string | undefined>;
+    charAt(pos: number): State<string>;
+    charCodeAt(index: number): State<number>;
+    codePointAt(pos: number): State<number | undefined>;
+    concat(...strings: string[]): State<string>;
+    endsWith(searchString: string, endPosition?: number): State<boolean>;
+    includes(searchString: string, position?: number): State<boolean>;
+    indexOf(searchString: string, position?: number): State<number>;
+    lastIndexOf(searchString: string, position?: number): State<number>;
+    localeCompare(that: string, locales?: string | string[], options?: Intl.CollatorOptions): State<number>;
+    match(regexp: string | RegExp): State<RegExpMatchArray | null>;
+    matchAll(regexp: RegExp): State<IterableIterator<RegExpMatchArray>>;
+    normalize(form?: string): State<string>;
+    padEnd(maxLength: number, fillString?: string): State<string>;
+    padStart(maxLength: number, fillString?: string): State<string>;
+    repeat(count: number): State<string>;
+    replace(searchValue: string | RegExp, replaceValue: string): State<string>;
+    replace(searchValue: string | RegExp, replacer: (substring: string, ...args: unknown[]) => string): State<string>;
+    replaceAll(searchValue: string | RegExp, replaceValue: string): State<string>;
+    replaceAll(searchValue: string | RegExp, replacer: (substring: string, ...args: unknown[]) => string): State<string>;
+    search(regexp: string | RegExp): State<number>;
+    slice(start?: number, end?: number): State<string>;
+    split(separator: string | RegExp | undefined, limit?: number): ArrayState<string>;
+    startsWith(searchString: string, position?: number): State<boolean>;
+    substring(start: number, end?: number): State<string>;
+    toLocaleLowerCase(locales?: string | string[]): State<string>;
+    toLocaleUpperCase(locales?: string | string[]): State<string>;
+    toLowerCase(): State<string>;
+    toString(): string;
+    toUpperCase(): State<string>;
+    trim(): State<string>;
+    trimEnd(): State<string>;
+    trimStart(): State<string>;
+    valueOf(): string;
+};
+type NumberState = {
+    toExponential(fractionDigits?: number): State<string>;
+    toFixed(fractionDigits?: number): State<string>;
+    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): State<string>;
+    toPrecision(precision?: number): State<string>;
+    toString(radix?: number): string;
+    valueOf(): number;
+};
+type BigIntState = {
+    toLocaleString(locales?: string, options?: object): State<string>;
+    toString(radix?: number): string;
+    valueOf(): bigint;
+};
+type BooleanState = {
+    toString(): string;
+    valueOf(): boolean;
+};
+type SymbolState = {
+    toString(): string;
+    valueOf(): symbol;
+};
+type PrimitiveStates<T> = T extends string ? StringState : T extends number ? NumberState : T extends boolean ? BooleanState : T extends bigint ? BigIntState : T extends symbol ? SymbolState : unknown;
+export type PrimitiveStateMethods<T> = {
+    opt: OptType<T>;
+    or: OrType<T>;
+    set(v: MaybeState<T>): void;
+    not: () => State<boolean>;
+    is: (v: unknown) => State<boolean>;
+} & StateBrand;
+export type PrimitiveState<T = unknown, Full = T> = PrimitiveStates<T> & T & PrimitiveStateMethods<Full>;
+type NullishState<Full> = PrimitiveStateMethods<Full> & {
+    [key: string]: undefined;
+};
+export type FunctionState<T = unknown, Full = T> = (T extends (...args: infer A) => infer R ? (...args: A) => State<R> : T) & {
+    opt: OptType<Full>;
+    or: OrType<Full>;
+    set(v: MaybeState<Full>): void;
+} & StateBrand;
+export type ArrayState<T, Full = T[]> = {
+    filter<S extends T>(predicate: (value: State<T>, index: number, array: ArrayState<T>) => value is State<S>, thisArg?: unknown): ArrayState<S>;
+    filter(predicate: (value: State<T>, index: number, array: ArrayState<T>) => unknown, thisArg?: unknown): ArrayState<T>;
+    map<U>(callbackfn: (value: State<T>, index: State<number>, array: ArrayState<T>) => U, thisArg?: unknown): ArrayState<U>;
+    flatMap<U, This = undefined>(callback: (this: This, value: State<T>, index: number, array: ArrayState<T>) => U | ReadonlyArray<U>, thisArg?: This): ArrayState<U>;
+    find<S extends T>(predicate: (value: State<T>, index: number, obj: ArrayState<T>) => value is State<S>, thisArg?: unknown): State<S | undefined>;
+    find(predicate: (value: State<T>, index: number, obj: ArrayState<T>) => unknown, thisArg?: unknown): State<T | undefined>;
+    findLast<S extends T>(predicate: (value: State<T>, index: number, array: ArrayState<T>) => value is State<S>, thisArg?: unknown): State<S | undefined>;
+    findLast(predicate: (value: State<T>, index: number, array: ArrayState<T>) => unknown, thisArg?: unknown): State<T | undefined>;
+    findIndex(predicate: (value: State<T>, index: number, obj: ArrayState<T>) => unknown, thisArg?: unknown): State<number>;
+    findLastIndex(predicate: (value: State<T>, index: number, array: ArrayState<T>) => unknown, thisArg?: unknown): State<number>;
+    reduce(callbackfn: (previousValue: State<T>, currentValue: State<T>, currentIndex: number, array: ArrayState<T>) => T): State<T>;
+    reduce(callbackfn: (previousValue: T, currentValue: State<T>, currentIndex: number, array: ArrayState<T>) => T, initialValue: T): State<T>;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: State<T>, currentIndex: number, array: ArrayState<T>) => U, initialValue: U): State<U>;
+    reduceRight(callbackfn: (previousValue: State<T>, currentValue: State<T>, currentIndex: number, array: ArrayState<T>) => T): State<T>;
+    reduceRight(callbackfn: (previousValue: T, currentValue: State<T>, currentIndex: number, array: ArrayState<T>) => T, initialValue: T): State<T>;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: State<T>, currentIndex: number, array: ArrayState<T>) => U, initialValue: U): State<U>;
+    some(predicate: (value: State<T>, index: number, array: ArrayState<T>) => unknown, thisArg?: unknown): State<boolean>;
+    every<S extends T>(predicate: (value: State<T>, index: number, array: ArrayState<T>) => value is State<S>, thisArg?: unknown): State<boolean>;
+    every(predicate: (value: State<T>, index: number, array: ArrayState<T>) => unknown, thisArg?: unknown): State<boolean>;
+    includes(searchElement: T, fromIndex?: number): State<boolean>;
+    indexOf(searchElement: T, fromIndex?: number): State<number>;
+    lastIndexOf(searchElement: T, fromIndex?: number): State<number>;
+    at(index: number): State<T | undefined>;
+    slice(start?: number, end?: number): ArrayState<T>;
+    concat(...items: ConcatArray<T>[]): ArrayState<T>;
+    concat(...items: (T | ConcatArray<T>)[]): ArrayState<T>;
+    join(separator?: string): State<string>;
+    toString(): string;
+    toLocaleString(): State<string>;
+    sort(compareFn?: (a: T, b: T) => number): ArrayState<T, Full>;
+    toSorted(compareFn?: (a: T, b: T) => number): ArrayState<T>;
+    toReversed(): ArrayState<T>;
+    toSpliced(start: number, deleteCount: number, ...items: T[]): ArrayState<T>;
+    toSpliced(start: number, deleteCount?: number): ArrayState<T>;
+    with(index: number, value: T): ArrayState<T>;
+    keys(): State<IterableIterator<number>>;
+    values(): State<IterableIterator<T>>;
+    entries(): State<IterableIterator<[number, T]>>;
+    opt: OptType<Full>;
+    or: OrType<Full>;
+    set(v: MaybeState<Full>): void;
+    [K: number]: State<T>;
+} & T[] & StateBrand;
+type ObjectStateMember<T, K extends keyof T> = K extends 'toString' | 'valueOf' ? T[K] : State<T[K]>;
+export type ObjectState<T, Full = T> = {
+    [K in keyof T]: ObjectStateMember<T, K>;
+} & {
+    set(v: MaybeState<Full>): void;
+} & {
+    [key: string]: unknown;
+} & ObjectStateOf<T>;
+export type DOMObjectState<T, Full = T> = {
+    [K in keyof T as K extends 'catch' ? never : K]: State<T[K]>;
+} & {
+    set(v: MaybeState<Full>): void;
+} & {
+    [key: string]: unknown;
+} & ObjectStateOf<T> & {
+    opt: OptType<Full>;
+    or: OrType<Full>;
+    catch: CatchType<Full>;
+};
+type StateImpl<Member, Full> = Member extends StateBrand ? Member : Member extends number ? PrimitiveState<number, Full> : Member extends string ? PrimitiveState<string, Full> : Member extends boolean ? PrimitiveState<boolean, Full> : Member extends Array<infer U> ? ArrayState<U, Full> : Member extends ArrayState<infer U> ? ArrayState<U, Full> : Member extends Function ? FunctionState<Member, Full> : Member extends NodeController ? DOMObjectState<Member, Full> : Member extends object ? ObjectState<Member, Full> : [Member] extends [Nullish] ? NullishState<Full> : PrimitiveState<Member, Full>;
+export type State<T = unknown> = StateImpl<T, T>;
+export {};

package/dist/state/types/types.d.ts

@@ -0,0 +1,35 @@
+import { STATE_ARRAY, STATE_DOMOBJECT, STATE_FUNCTION, STATE_OBJECT, STATE_POJO, STATE_PRIMITIVE } from '../../state/stateInternals/internalFunctions.js';
+import { State } from './stateTypes.js';
+import { LightState } from '../stateInternals/LightState.js';
+export type { PrimitiveState, FunctionState, ArrayState, ObjectState, OptType, State, PrimitiveStateMethods, ValueOfState, MaybeState, ObjectStateOf, SomeState, } from './stateTypes.js';
+export type SubscribeCallback<Value = unknown, Data = unknown> = (n: Value, s?: Data) => void;
+export type SubscribeOptions = {
+    deep?: boolean;
+};
+export type ChangeRecord = {
+    path?: (string | number)[];
+    value?: unknown;
+    oldValue?: unknown;
+    done?: boolean;
+    reorder?: boolean;
+    remove?: number[];
+    add?: number[];
+    common?: number[];
+    prefixL?: number;
+    suffixL?: number;
+    addedValues?: unknown[];
+    removedValues?: unknown[];
+};
+export type Version = number;
+export type OptOption<T = unknown> = T | T[] | Record<string, T>;
+export type MapFunction = (value: unknown, index: number, array: unknown[]) => unknown;
+export type InternalStateTarget<T = unknown> = LightState<T & Record<PropertyKey, unknown>>;
+export type InternalFunction<T = unknown> = (target: InternalStateTarget<T>, receiver: IState<T>) => unknown;
+export type InternalFunctionMap = Map<PropertyKey, InternalFunction>;
+export type IState<T = unknown> = {
+    [Symbol.toPrimitive]: (...args: unknown[]) => unknown;
+    toString: () => string;
+    valueOf: () => T;
+} & State<T>;
+export type AnyState<T = unknown> = LightState<T> | IState<T>;
+export type StateType = typeof STATE_PRIMITIVE | typeof STATE_ARRAY | typeof STATE_POJO | typeof STATE_FUNCTION | typeof STATE_OBJECT | typeof STATE_DOMOBJECT;

package/dist/undo/undo.d.ts

@@ -0,0 +1,39 @@
+import { ChangeRecord, SomeState, State } from '../state/types/types.js';
+export type { ChangeRecord } from '../state/types/types.js';
+export type HistoryEntry = {
+    batch: ChangeRecord[];
+    t: number;
+};
+type TrackHistoryOptions = {
+    limit?: number;
+    addHistoryVersion?: () => number;
+};
+export declare class TrackHistory<S extends SomeState> {
+    private readonly tracked;
+    private readonly opts?;
+    private readonly undoStack;
+    private readonly redoStack;
+    private batch;
+    private applying;
+    private batching;
+    private readonly unsub;
+    undoEmpty: State<boolean>;
+    redoEmpty: State<boolean>;
+    historyVersions: State<number[]>;
+    private onChange;
+    private finalizeBatch;
+    private updateDerivedState;
+    constructor(root: S, opts?: TrackHistoryOptions);
+    private walkToNode;
+    private applyReorder;
+    private applyChange;
+    private replay;
+    undo: () => boolean;
+    redo: () => boolean;
+    restoreAt(timestamp: number): void;
+    startBatch(): void;
+    commitBatch(): void;
+    getHistory(): HistoryEntry[];
+    setHistory(history: HistoryEntry[]): void;
+    unsubscribe(): void;
+}