@farm.js/react 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/compiler-runtime.d.ts

@@ -8,29 +8,156 @@ interface CompilerCell {
 interface CompilerTextBinding<Props> {
     kind: "text";
     path: readonly number[];
+    /** Stable ref target emitted by newer compiler versions. */
+    target?: number;
     dependencies: readonly number[];
     read(props: Props, state: readonly CompilerCell[]): unknown;
 }
 interface CompilerAttributeBinding<Props> {
     kind: "attribute";
     path: readonly number[];
+    /** Stable ref target emitted by newer compiler versions. */
+    target?: number;
     dependencies: readonly number[];
     name: string;
     read(props: Props, state: readonly CompilerCell[]): unknown;
 }
-type CompilerBinding<Props> = CompilerTextBinding<Props> | CompilerAttributeBinding<Props>;
+interface CompilerStyleBinding<Props> {
+    kind: "style";
+    path: readonly number[];
+    /** Stable ref target emitted by newer compiler versions. */
+    target?: number;
+    dependencies: readonly number[];
+    name: string;
+    read(props: Props, state: readonly CompilerCell[]): unknown;
+}
+interface CompilerConditionalBlockBinding {
+    kind: "block";
+    id: number;
+    /** Nearest conditional boundary that owns this block, when nested. */
+    parent?: number;
+    dependencies: readonly number[];
+}
+interface CompilerConditionalBlockProps {
+    id: number;
+    render(): React.ReactNode;
+}
+interface CompilerKeyedListBlockProps {
+    id: number;
+    render(): React.ReactNode;
+}
+interface CompilerHostElement {
+    kind: "element";
+    tag: string;
+    attributes: readonly {
+        name: string;
+        value: unknown;
+    }[];
+    styles: readonly {
+        name: string;
+        value: unknown;
+    }[];
+    children: readonly (CompilerHostElement | unknown)[];
+}
+type CompilerKeyedRowElement = CompilerHostElement;
+interface CompilerKeyedRowEvent {
+    name: string;
+    invoke(item: unknown, index: number, event: React.SyntheticEvent): unknown;
+}
+interface CompilerKeyedRowConditionalBranch {
+    bindings: readonly CompilerKeyedRowBinding[];
+}
+interface CompilerKeyedRowConditional {
+    id: number;
+    /** Host-container path relative to the keyed row root. */
+    path: readonly number[];
+    test(item: unknown, index: number): unknown;
+    logical: boolean;
+    truthy?: CompilerKeyedRowConditionalBranch;
+    falsy?: CompilerKeyedRowConditionalBranch;
+}
+interface CompilerHostConditionalBinding {
+    kind: "text" | "attribute" | "style";
+    path: readonly number[];
+    name?: string;
+    read(): unknown;
+}
+interface CompilerHostConditionalBranch {
+    create(): CompilerHostElement;
+    bindings: readonly CompilerHostConditionalBinding[];
+}
+interface CompilerHostConditionalBlockProps {
+    id: number;
+    render(): React.ReactElement;
+    test(): unknown;
+    /** Logical && can produce a visible number instead of an empty branch. */
+    logical?: boolean;
+    truthy?: CompilerHostConditionalBranch;
+    falsy?: CompilerHostConditionalBranch;
+}
+interface CompilerKeyedRowBinding {
+    kind: "text" | "attribute" | "style";
+    path: readonly number[];
+    name?: string;
+    read(item: unknown, index: number): unknown;
+}
+interface CompilerKeyedRowsBlockProps {
+    id: number;
+    render(event: (item: unknown, index: number, eventId: number) => React.EventHandler<React.SyntheticEvent>, conditional: (item: unknown, index: number, conditionalId: number, render: (item: unknown, index: number) => React.ReactNode) => React.ReactNode): React.ReactElement;
+    items(): Iterable<unknown> | null | undefined;
+    rowKey(item: unknown, index: number): React.Key;
+    create(item: unknown, index: number): CompilerKeyedRowElement;
+    bindings: readonly CompilerKeyedRowBinding[];
+    events?: readonly CompilerKeyedRowEvent[];
+    conditionals?: readonly CompilerKeyedRowConditional[];
+}
+interface CompilerKeyedRange {
+    /** Number of static direct host siblings between this range and the previous range. */
+    before: number;
+    items(): Iterable<unknown> | null | undefined;
+    rowKey(item: unknown, index: number): React.Key;
+    create(item: unknown, index: number): CompilerKeyedRowElement;
+    bindings: readonly CompilerKeyedRowBinding[];
+}
+interface CompilerKeyedRangesBlockProps {
+    id: number;
+    render(): React.ReactElement;
+    rootRef?: React.RefCallback<Element>;
+    ranges: readonly CompilerKeyedRange[];
+    /** Number of static direct host siblings after the final keyed range. */
+    trailing: number;
+}
+interface CompilerComponentBlockProps {
+    id: number;
+    render(): React.ReactNode;
+}
+interface CompilerBlockRuntime {
+    Conditional: React.ComponentType<CompilerConditionalBlockProps>;
+    HostConditional: React.ComponentType<CompilerHostConditionalBlockProps>;
+    KeyedList: React.ComponentType<CompilerKeyedListBlockProps>;
+    KeyedRows: React.ComponentType<CompilerKeyedRowsBlockProps>;
+    KeyedRanges: React.ComponentType<CompilerKeyedRangesBlockProps>;
+    Component: React.ComponentType<CompilerComponentBlockProps>;
+    target(id: number): React.RefCallback<Element>;
+}
+type CompilerBinding<Props> = CompilerTextBinding<Props> | CompilerAttributeBinding<Props> | CompilerStyleBinding<Props> | CompilerConditionalBlockBinding;
 interface CompiledComponentDefinition<Props> {
     displayName: string;
+    /** Stable development-only identity used to preserve state across compatible refreshes. */
+    hmrId?: string;
+    /** Changes when the compiler-owned state layout is no longer refresh-compatible. */
+    stateSignature?: string;
     initialize(props: Props): readonly unknown[];
-    render(props: Props, state: readonly CompilerCell[]): React.ReactElement;
+    render(props: Props, state: readonly CompilerCell[], blocks: CompilerBlockRuntime): React.ReactElement;
     bindings: readonly CompilerBinding<Props>[];
 }
 /**
  * Runtime target emitted by the AOT transform.
  *
- * React owns component placement, SSR, hydration, props, and event semantics.
- * Compiler cells own local state updates and patch only precomputed DOM paths.
+ * React owns initial placement, SSR, hydration, props, and event semantics.
+ * Compiler cells own local updates and precomputed DOM paths. A proven host-only
+ * keyed container may transfer its child-row ownership after mount.
  */
 declare function createCompiledComponent<Props>(definition: CompiledComponentDefinition<Props>): React.ComponentType<Props>;
 
-export { type CompiledComponentDefinition, type CompilerAttributeBinding, type CompilerBinding, type CompilerCell, type CompilerStateUpdater, type CompilerTextBinding, createCompiledComponent };
+export { type CompiledComponentDefinition, type CompilerAttributeBinding, type CompilerBinding, type CompilerBlockRuntime, type CompilerCell, type CompilerComponentBlockProps, type CompilerConditionalBlockBinding, type CompilerConditionalBlockProps, type CompilerHostConditionalBinding, type CompilerHostConditionalBlockProps, type CompilerHostConditionalBranch, type CompilerHostElement, type CompilerKeyedListBlockProps, type CompilerKeyedRange, type CompilerKeyedRangesBlockProps, type CompilerKeyedRowBinding, type CompilerKeyedRowConditional, type CompilerKeyedRowConditionalBranch, type CompilerKeyedRowElement, type CompilerKeyedRowEvent, type CompilerKeyedRowsBlockProps, type CompilerStateUpdater, type CompilerStyleBinding, type CompilerTextBinding, createCompiledComponent };