creo 0.2.4 → 0.2.6

package/dist/public/primitives/primitives.d.ts

@@ -17,16 +17,41 @@ export type InputEventData = BaseEventData & {
     checked: boolean;
 };
 export type FocusEventData = BaseEventData;
+export type ScrollEventData = BaseEventData & {
+    scrollTop: number;
+    scrollLeft: number;
+};
+export type LoadEventData = BaseEventData;
+export type ErrorEventData = BaseEventData & {
+    message: string;
+};
+export type ToggleEventData = BaseEventData & {
+    open: boolean;
+};
+export type MediaEventData = BaseEventData & {
+    muted: boolean;
+    paused: boolean;
+    volume: number;
+    currentTime: number;
+    duration: number;
+};
 export type ContainerEvents = {
     click: (e: PointerEventData) => void;
     dblclick: (e: PointerEventData) => void;
     pointerDown: (e: PointerEventData) => void;
     pointerUp: (e: PointerEventData) => void;
     pointerMove: (e: PointerEventData) => void;
+    mouseEnter: (e: PointerEventData) => void;
+    mouseLeave: (e: PointerEventData) => void;
+    pointerEnter: (e: PointerEventData) => void;
+    pointerLeave: (e: PointerEventData) => void;
     keyDown: (e: KeyEventData) => void;
     keyUp: (e: KeyEventData) => void;
     focus: (e: FocusEventData) => void;
     blur: (e: FocusEventData) => void;
+    scroll: (e: ScrollEventData) => void;
+    load: (e: LoadEventData) => void;
+    error: (e: ErrorEventData) => void;
 };
 export type FormEvents = ContainerEvents & {
     input: (e: InputEventData) => void;
@@ -34,6 +59,26 @@ export type FormEvents = ContainerEvents & {
     keyDown: (e: KeyEventData) => void;
     keyUp: (e: KeyEventData) => void;
 };
+export type MediaEvents = ContainerEvents & {
+    volumeChange: (e: MediaEventData) => void;
+    play: (e: MediaEventData) => void;
+    pause: (e: MediaEventData) => void;
+    ended: (e: MediaEventData) => void;
+    timeUpdate: (e: MediaEventData) => void;
+    loadedMetadata: (e: MediaEventData) => void;
+    loadedData: (e: MediaEventData) => void;
+    canPlay: (e: MediaEventData) => void;
+    canPlayThrough: (e: MediaEventData) => void;
+    durationChange: (e: MediaEventData) => void;
+    rateChange: (e: MediaEventData) => void;
+    seeking: (e: MediaEventData) => void;
+    seeked: (e: MediaEventData) => void;
+    stalled: (e: MediaEventData) => void;
+    waiting: (e: MediaEventData) => void;
+};
+export type DisclosureEvents = ContainerEvents & {
+    toggle: (e: ToggleEventData) => void;
+};
 export type HtmlAttrs = {
     class?: string;
     id?: string;
@@ -159,14 +204,14 @@ export declare const video: PublicView<HtmlAttrs & {
     muted?: boolean;
     width?: number;
     height?: number;
-} & EventHandlerProps<ContainerEvents>, void>;
+} & EventHandlerProps<MediaEvents>, void>;
 export declare const audio: PublicView<HtmlAttrs & {
     src?: string;
     controls?: boolean;
     autoplay?: boolean;
     loop?: boolean;
     muted?: boolean;
-} & EventHandlerProps<ContainerEvents>, void>;
+} & EventHandlerProps<MediaEvents>, void>;
 export declare const canvas: PublicView<HtmlAttrs & {
     width?: number;
     height?: number;
@@ -177,11 +222,11 @@ export declare const source: PublicView<HtmlAttrs & {
 } & EventHandlerProps<ContainerEvents>, void>;
 export declare const details: PublicView<HtmlAttrs & {
     open?: boolean;
-} & EventHandlerProps<ContainerEvents>, void>;
+} & EventHandlerProps<DisclosureEvents>, void>;
 export declare const summary: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
 export declare const dialog: PublicView<HtmlAttrs & {
     open?: boolean;
-} & EventHandlerProps<ContainerEvents>, void>;
+} & EventHandlerProps<DisclosureEvents>, void>;
 export declare const menu: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
 export declare const iframe: PublicView<HtmlAttrs & {
     src?: string;

package/dist/public/state.d.ts

@@ -16,6 +16,12 @@ export interface Reactive<T> {
  *   count.get()              // read current value
  *   count.set(5)             // set immediately, schedule render
  *   count.update(n => n + 1) // update via fn, schedule render
+ *
+ * Async updates chain: a second `update` issued while a previous async
+ * update is still in flight runs against the previous update's result,
+ * not against the snapshot at issue time. `set` cancels any pending
+ * chain — its value becomes authoritative and in-flight links won't
+ * commit afterwards.
  */
 export declare class State<T> implements Reactive<T> {
     #private;

package/dist/public/view.d.ts

@@ -1,18 +1,14 @@
 import type { Key } from "../functional/key";
 import type { Use } from "./state";
 import type { $primitive } from "./primitive";
-export type ViewBody<Props, Api> = Api extends void ? {
-    render: () => void;
-    onMount?: () => void;
-    shouldUpdate?: (nextProps: Props) => boolean;
-    onUpdateBefore?: () => void;
-    onUpdateAfter?: () => void;
-} : {
+type ViewBodyBase<Props> = {
     render: () => void;
     onMount?: () => void;
     shouldUpdate?: (nextProps: Props) => boolean;
     onUpdateBefore?: () => void;
     onUpdateAfter?: () => void;
+};
+export type ViewBody<Props, Api> = Api extends void ? ViewBodyBase<Props> : ViewBodyBase<Props> & {
     api: Api;
 };
 /** Slot callback — passed by the caller at the call site. */

package/dist/render/html_render.d.ts

@@ -8,6 +8,13 @@ export declare class HtmlRender implements IRender<HTMLElement | Text> {
     constructor(container: HTMLElement);
     render(view: ViewRecord): void;
     unmount(view: ViewRecord): void;
+    /**
+     * Re-render only when a stateful DOM property in `nextProps` actually
+     * differs from the live DOM. With this in place a 50-input form whose
+     * parent re-renders touches the DOM only for the input the user is
+     * actually editing.
+     */
+    shouldReassert(view: ViewRecord, nextProps: unknown): boolean;
     private findParentDom;
     private findInsertionPoint;
     private setAttributes;

package/dist/render/render_interface.d.ts

@@ -6,4 +6,18 @@ export interface IRender<Output> {
     render(view: ViewRecord): void;
     /** Remove a view's output artifacts. */
     unmount(view: ViewRecord): void;
+    /**
+     * Optional: returns true if this primitive's live output may have
+     * drifted from `nextProps` and needs re-rendering even though
+     * `shallowEqual(prev, next)` reports props as unchanged.
+     *
+     * The DOM renderer uses this to detect user input that changed
+     * the live DOM (e.g. typing in `<input value=…>`, toggling a
+     * checkbox) without our state ever changing.
+     *
+     * Called only for primitives whose own props didn't change
+     * shallowly — engines should treat absence of this method as
+     * "nothing to re-assert".
+     */
+    shouldReassert?(view: ViewRecord, nextProps: unknown): boolean;
 }

package/dist/render/string_render.d.ts

@@ -18,5 +18,3 @@ export declare class HtmlStringRender implements IRender<string> {
     private buildAttrs;
     private buildChildren;
 }
-/** @deprecated Use HtmlStringRender instead */
-export declare const StringRender: typeof HtmlStringRender;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "creo",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/dist/public/event_handle.d.ts

@@ -1,32 +0,0 @@
-import type { Wildcard } from "../internal/wildcard";
-type EventCallback = (...args: Wildcard[]) => void;
-/**
- * Delegate that the renderer provides to wire event subscriptions
- * to the actual output (DOM addEventListener, etc.).
- * Set on the EventHandle after the view's output is created.
- */
-export type EventDelegate = {
-    bind(event: string, callback: EventCallback, once?: boolean): void;
-    unbind(event: string, callback: EventCallback): void;
-};
-/**
- * Handle returned when calling a primitive in the render stream.
- * Provides on/once/off for event subscription.
- *
- * When a delegate is set (by the renderer after mount), calls are
- * proxied to the renderer — only events the user subscribes to
- * get bound. Before the delegate exists, listeners are stored and
- * flushed once the delegate arrives.
- */
-export declare class EventHandle<Events> {
-    #private;
-    on<K extends keyof Events>(event: K, callback: Events[K]): void;
-    once<K extends keyof Events>(event: K, callback: Events[K]): void;
-    off<K extends keyof Events>(event: K, callback: Events[K]): void;
-    /**
-     * Called by the renderer after the view's output is created.
-     * Flushes any listeners that were added before the delegate existed.
-     */
-    setDelegate(delegate: EventDelegate): void;
-}
-export {};

package/dist/render/canvas_render.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/render/stream_render.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/structures/indexed_list.d.ts

@@ -1,46 +0,0 @@
-/**
- * IndexedList — linked list with O(1) identity-based lookup.
- *
- * Combines a doubly-linked list (O(1) insert/delete given a node)
- * with a Map<T, INode<T>> for O(1) lookup by value identity.
- *
- * All mutating operations are O(1):
- *   push, delete, has, first, last, clear
- */
-import { type INode } from "./list";
-import type { Maybe } from "../functional/maybe";
-export declare class IndexedList<T> {
-    #private;
-    /** Append item to the end. No-op if already present. Returns the node. */
-    push(item: T): INode<T>;
-    /** Insert item at the front. No-op if already present. */
-    unshift(item: T): void;
-    /** Insert item after ref. No-op if item already present. */
-    insertAfter(ref: T, item: T): void;
-    /** Remove item. O(1). */
-    delete(item: T): void;
-    /** Check membership. O(1). */
-    has(item: T): boolean;
-    /** Number of items. */
-    get length(): number;
-    /** Get the first item (head). O(1). */
-    first(): Maybe<T>;
-    /** Get the last item (tail). O(1). */
-    last(): Maybe<T>;
-    /** Get the linked-list node for an item. O(1). */
-    getNode(item: T): Maybe<INode<T>>;
-    /** Positional access. O(n) — prefer getNode + getNext for traversal. */
-    at(index: number): Maybe<T>;
-    /**
-     * Replace item at `pos`, or insert if nothing is there.
-     * If `pos >= length`, appends to the end.
-     * Returns the node.
-     */
-    upsert(pos: number, item: T): INode<T>;
-    /** Swap two items in the list. O(1). No-op if either item is missing. */
-    swap(a: T, b: T): void;
-    /** Reset to empty. O(1). */
-    clear(): void;
-    /** Iterate values in insertion order. */
-    [Symbol.iterator](): IterableIterator<T>;
-}

package/dist/structures/list.d.ts

@@ -1,68 +0,0 @@
-/**
- * Linked list implementation
- */
-import type { Maybe } from "../functional/maybe";
-declare const $next: unique symbol;
-declare const $prev: unique symbol;
-declare const $owner: unique symbol;
-export interface INode<T> {
-    insertNext(value: T): INode<T>;
-    insertPrev(value: T): INode<T>;
-    v: T;
-    delete(): void;
-    getNext(): Maybe<INode<T>>;
-    getPrev(): Maybe<INode<T>>;
-    isFirst(): boolean;
-    isLast(): boolean;
-}
-export declare class ListNode<T> implements INode<T> {
-    [$owner]: Maybe<IBaseContainer<T>>;
-    [$next]: Maybe<ListNode<T>>;
-    [$prev]: Maybe<ListNode<T>>;
-    v: T;
-    constructor(node: T, prev: Maybe<ListNode<T>>, next: Maybe<ListNode<T>>, list: IBaseContainer<T>);
-    isFirst(): boolean;
-    isLast(): boolean;
-    delete(): void;
-    clearFields(): void;
-    insertNext(value: T): INode<T>;
-    insertPrev(value: T): INode<T>;
-    getNext(): Maybe<ListNode<T>>;
-    getPrev(): Maybe<ListNode<T>>;
-    getList(): Maybe<IBaseContainer<T>>;
-}
-interface IBaseContainer<T> {
-    delete(node: INode<T>): void;
-    insertNext(ref: INode<T>, value: T): INode<T>;
-    insertPrev(ref: INode<T>, value: T): INode<T>;
-}
-export interface IList<T> extends Iterable<INode<T>>, IBaseContainer<T> {
-    insertStart(value: T): INode<T>;
-    insertEnd(value: T): INode<T>;
-    at(n: number): Maybe<INode<T>>;
-    first(): Maybe<INode<T>>;
-    last(): Maybe<INode<T>>;
-    readonly size: number;
-    [Symbol.iterator](): IterableIterator<INode<T>>;
-}
-export declare class InternalList<T> implements IList<T> {
-    #private;
-    insertStart(value: T): ListNode<T>;
-    delete(node: INode<T>): void;
-    at(n: number): Maybe<ListNode<T>>;
-    get size(): number;
-    /** Reset the list to empty. O(1). */
-    clear(): void;
-    /** O(1) head access. */
-    first(): Maybe<ListNode<T>>;
-    /** O(1) tail access. */
-    last(): Maybe<ListNode<T>>;
-    insertEnd(value: T): ListNode<T>;
-    insertNext(ref: INode<T>, value: T): ListNode<T>;
-    insertPrev(ref: INode<T>, value: T): ListNode<T>;
-    [Symbol.iterator](): Generator<ListNode<T>, void, unknown>;
-}
-export declare class List<T> extends InternalList<T> implements IList<T> {
-    static from<T>(arrayLike: Iterable<T>): List<T>;
-}
-export {};