@source-crafter/xzor-runtime 0.1.8 → 0.1.10

package/entity-set.d.ts

@@ -0,0 +1,35 @@
+import { Model } from "./model";
+export declare class EntitySet<T extends Model> extends Array<T> {
+    #private;
+    static get [Symbol.species](): ArrayConstructor;
+    /** Builds a set from server data: `Array.of` and `Array.from` keep their own meaning. */
+    static track<T extends Model>(type: new (data?: object) => T, items?: Iterable<object>): EntitySet<T>;
+    /** @internal The model this set belongs to, and the index of the field holding it. */
+    $own(owner: Model, index: number): void;
+    /** @internal */
+    $watch(dep: object): void;
+    /** @internal */
+    $unwatch(dep: object): void;
+    [Symbol.iterator](): ArrayIterator<T>;
+    /** The items to show: everything but the deleted ones. */
+    get view(): T[];
+    get hasChanges(): boolean;
+    get hasErrors(): boolean;
+    /** What to send to the server: only the items that changed, each as its own `changes`. */
+    get changes(): Record<string, unknown>[];
+    /** Added items leave the set, the others are marked Deleted; a Detached one is left alone. */
+    delete(...items: T[]): this;
+    revertChanges(): this;
+    /**
+     * Takes the list the server confirmed: a `null` at an index drops that item, as do the deleted ones.
+     * Items past the end of a shorter server list are left exactly as they are.
+     */
+    confirmChanges(items?: readonly (object | null)[]): this;
+    push(...items: T[]): number;
+    unshift(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    sort(compare?: (a: T, b: T) => number): this;
+    reverse(): T[];
+}

package/fine.d.ts

@@ -0,0 +1,62 @@
+import { ComponentBase, type RenderTreeBuilder } from "./index";
+type Build = (parent: Node) => void;
+/** The element type of tag `K`. */
+export type El<K extends string> = K extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[K] : HTMLElement;
+/**
+ * What generated `@fine` code calls. A run of nodes is a `template` clone; the `...At` calls bind the nodes it
+ * has in place, and the `...Item` ones bind a row's nodes to a read its list shares (`reads[i]`, given the item).
+ * The others append the node they bind to `parent`.
+ */
+export declare const fine: {
+    /**
+     * Builds the nodes of `specs` (a fragment unless they are one element). The first call builds them directly:
+     * a component used once keeps no copy. From the second on, calls clone a copy built then.
+     */
+    template(specs: readonly unknown[]): () => Node;
+    el<K extends string>(parent: Node, tag: K): El<K>;
+    /** A handler; afterwards the component re-runs its bindings that read nothing tracked. */
+    on(el: Element, event: string, handler: (e: any) => unknown): void;
+    /** A row's handler: `reads[i](item)` gives it. */
+    onItem(el: Element, event: string, i: number): void;
+    /** Static text. */
+    t(parent: Node, text: string): void;
+    /** Text that follows `read()`; markup (a `RenderFragment`) renders as markup. */
+    text(parent: Node, read: () => unknown): void;
+    textAt(node: Text, read: () => unknown): void;
+    textItem(node: Text, i: number): void;
+    /** Attribute `name` of `el` that follows `read()`; `false`/`null`/`undefined` remove it. */
+    attr(el: Element, name: string, read: () => unknown): void;
+    attrItem(el: Element, name: string, i: number): void;
+    /** `@if`, `@switch`, a `@for` that is not a plain list, `@{ }`: rebuilt whenever what `build` read changes. */
+    region(parent: Node, build: Build): void;
+    /** A region between `end` and the comment before it. */
+    regionAt(end: Comment, build: Build): void;
+    /** A row's region: `reads[i](item, parent)` builds it. */
+    regionItem(end: Comment, i: number): void;
+    /** `@for (const item of items)`: one row per item, matched by identity; a row is built once. */
+    list<T>(parent: Node, items: () => Iterable<T>, build: (parent: Node, item: T) => void): void;
+    /** A list before `end`; its rows' bindings use `reads`, shared by the rows. */
+    listAt<T>(end: Comment, items: () => Iterable<T>, reads: readonly ((item: T, x?: any) => any)[], build: (parent: Node, item: T) => void): void;
+    /** Child components, slots, `@cascade`, routes: virtual-DOM builder calls, patched when what they read changes. */
+    island(parent: Node, build: (b: RenderTreeBuilder) => void): void;
+    islandAt(end: Comment, build: (b: RenderTreeBuilder) => void): void;
+};
+/**
+ * Base of `@fine` components. The bundle turns their fields into tracked ones, as it does a model's, so a
+ * handler that writes a field updates what reads it. `stateHasChanged()` re-runs every binding.
+ */
+export declare abstract class FineComponent extends ComponentBase {
+    #private;
+    /** @internal What tracked getters report to; the bundle emits `FineComponent.$reader?.(this, i)`. */
+    static get $reader(): ((source: object, index: number) => void) | undefined;
+    static same(a: unknown, b: unknown): boolean;
+    /** @internal Records a class's tracked fields after its base's; returns where they start. */
+    static $define(cls: Function, names: string[]): number;
+    /** @internal */
+    $watch(dep: object): void;
+    /** @internal */
+    $unwatch(dep: object): void;
+    /** @internal What a tracked setter reports once it stored a different value. */
+    protected $changed(index: number, _previous: unknown): void;
+}
+export {};