@oasys/oecs 0.5.3 → 0.6.0

package/dist/extensions/reactive/ecs_sync.d.cts

@@ -1,214 +0,0 @@
-import { ReactiveArray, ReactiveMap, StructSetters, StructEq } from '../../reactive/index.cjs';
-import { ComponentDef, ComponentSchema, ECS, EntityID, SystemAccessDeclaration } from '../../core/ecs/index.cjs';
-import { shallow } from '../../reactive/shallow.cjs';
-export { shallow };
-/**
- * A read cursor over one entity's single-component state, handed to a single-
- * component `Projection`. `field` is column-backed under "column" grain
- * (sequential), random-access (`getField`) under "entity" grain.
- *
- * Lifetime: the cursor is a reused, mutable singleton valid ONLY during the
- * synchronous `project` call for the current row. Read what you need and return —
- * never capture `row` (or stash its `field` reads keyed off a later closure): the
- * next row/tick mutates it in place, so a captured cursor reads stale data.
- */
-export interface RowReader<S extends ComponentSchema> {
-    /** The current entity (the row being projected). */
-    readonly eid: EntityID;
-    /** Read a field of the synced component for the current row. */
-    field<K extends string & keyof S>(name: K): number;
-}
-/**
- * A read cursor over a JOINED entity (it carries every component in the join), for
- * a `JoinProjection`. `field(def, name)` reads any field of any joined component
- * for the current entity (random-access; the join subscribes to all of them so the
- * read can never go stale).
- *
- * Lifetime: like `RowReader`, a reused mutable singleton valid ONLY during the
- * synchronous `project` call — never capture it; the next dispatch mutates it.
- */
-export interface JoinReader<Schemas extends readonly ComponentSchema[] = readonly ComponentSchema[]> {
-    /** The current entity (it has all joined components). */
-    readonly eid: EntityID;
-    /** Read a field of one joined component for the current entity. `def` is
-     * constrained to the join's own component set — reading a def outside the
-     * join is the stale-read footgun the module header warns about (its changes
-     * aren't subscribed), so it's a compile error. */
-    field<S extends Schemas[number], K extends string & keyof S>(def: ComponentDef<S>, name: K): number;
-}
-/** Map one single-component row to the value a UI cell reads. */
-export type Projection<S extends ComponentSchema, V> = (row: RowReader<S>) => V;
-/** Map one joined entity to the value a UI cell reads. */
-export type JoinProjection<V, Schemas extends readonly ComponentSchema[] = readonly ComponentSchema[]> = (row: JoinReader<Schemas>) => V;
-/** Per-component dirty grain. See the module header for the measured crossover. */
-export type SyncGrain = "entity" | "column";
-export interface EcsMapSyncOptions<V> {
-    /** Dirty grain (default `"entity"`). Use `"column"` for high-churn components. */
-    grain?: SyncGrain;
-    /**
-     * Value equality for the map's per-key no-op skip (default `Object.is`). Pass
-     * `shallow` for object projections, or a content comparator. A fresh object
-     * every tick under the default reference eq wakes the row every frame.
-     */
-    eq?: (a: V, b: V) => boolean;
-    /**
-     * Access surface the projection touches, merged over the synced components'
-     * `reads`. `DEV` access-checks the observer callbacks exactly like a system.
-     */
-    access?: Partial<SystemAccessDeclaration>;
-    /**
-     * Replay current matches on registration (default `true`), so a bridge attached
-     * to an already-populated world seeds the map with present state instead of
-     * waking only on the next change. flecs `yieldExisting`.
-     */
-    seedExisting?: boolean;
-}
-export interface EcsMapSync<V> {
-    /** The live channel: a reader of key `eid` subscribes to that entity alone. */
-    readonly map: ReactiveMap<EntityID, V>;
-    /** Unregister the observer(s) and stop publishing. Safe to call more than once. */
-    dispose(): void;
-}
-/**
- * Sync ONE component's change detection into a `reactiveMap`, keyed by `EntityID`.
- * A value change publishes the changed rows; a spawn inserts a row and a despawn
- * deletes it. Returns the map + a disposer. Drive with `batchedUpdate(world, dt)`.
- *
- * To read more than one component per row, use `syncJoinToMap` — reading a second
- * component here goes stale (its changes aren't subscribed).
- */
-export declare function syncComponentToMap<S extends ComponentSchema, V>(ecs: ECS, def: ComponentDef<S>, project: Projection<S, V>, opts?: EcsMapSyncOptions<V>): EcsMapSync<V>;
-/**
- * Sugar over `syncComponentToMap`: project a fixed FIELD LIST into a `{ field:
- * value }` snapshot, with an automatic `shallow` eq so an unchanged row wakes
- * nobody. The declarative-field-list model from WatermelonDB `observeWithColumns` /
- * TanStack `select` — the common "mirror these fields" case without hand-writing
- * the projection + comparator.
- *
- * Allocation note: this builds a fresh object per dirty row and `shallow` does two
- * `Object.keys` per compare — fine for low-churn. For a HIGH-churn component (the
- * case you'd pick `grain:"column"` for), prefer `syncComponentToMap` with a scalar
- * or hand-written-`eq` projection, so the hot path doesn't allocate exactly where
- * the column grain is meant to keep it cheap.
- */
-export declare function syncFieldsToMap<S extends ComponentSchema, const F extends readonly (string & keyof S)[]>(ecs: ECS, def: ComponentDef<S>, fields: F, opts?: Omit<EcsMapSyncOptions<{
-    [K in F[number]]: number;
-}>, "eq">): EcsMapSync<{
-    [K in F[number]]: number;
-}>;
-/**
- * Sync a multi-component JOIN into a `reactiveMap`. An entity is a member iff it
- * has EVERY component in `defs`; the projection reads any of them via
- * `row.field(def, name)`. Change detection subscribes to ALL joined components, so
- * a write to ANY of them republishes the row — the join can never go stale (the
- * bug a single-component sync + manual secondary read would have). Spawns/removes
- * of any joined component re-evaluate membership.
- *
- * Entity grain only: a join spans archetypes, so there is no single column to
- * sweep. Drive with `batchedUpdate(world, dt)`.
- */
-export declare function syncJoinToMap<Schemas extends readonly ComponentSchema[], V>(ecs: ECS, defs: readonly [...{
-    [I in keyof Schemas]: ComponentDef<Schemas[I]>;
-}], project: JoinProjection<V, Schemas>, opts?: Omit<EcsMapSyncOptions<V>, "grain">): EcsMapSync<V>;
-export interface SingletonStructSync<V extends object> {
-    /** The live per-field channel: reading `struct.field` in a tracked scope
-     * subscribes to that field alone (pair with `fromKernelStruct` to render). */
-    readonly struct: V;
-    /** Unregister the observer and stop publishing. Safe to call more than once. */
-    dispose(): void;
-}
-export interface SingletonSyncOptions<V extends object = Record<string, number>> {
-    /**
-     * Access surface the publish touches, merged over the synced def's read.
-     * `DEV` access-checks the observer callbacks exactly like a system.
-     */
-    access?: Partial<SystemAccessDeclaration>;
-    /** Replay current state on registration (default `true`). flecs `yieldExisting`. */
-    seedExisting?: boolean;
-    /**
-     * Drive a PRE-CREATED `reactiveStruct` (its `[proxy, set]` pair) instead of
-     * creating a fresh one. Lets the consumer keep the struct at module scope as a
-     * stable "channel" with initial values present before the sync attaches (the
-     * client UI seam: panels import the eager proxy; the sync, set up at world build,
-     * republishes into it via the observer). The seed (`yieldExisting`) overwrites
-     * the eager initials with the entity's current values on registration.
-     */
-    into?: readonly [V, StructSetters<V>];
-    /** Per-field equality overrides for the created struct (parity with
-     * `SingletonArraySyncOptions.eq`). Ignored when `into` supplies a
-     * pre-created struct — that struct already carries its own `eq`. */
-    eq?: StructEq<V>;
-}
-/**
- * Sync ONE singleton entity's single-component state into a `reactiveStruct`,
- * keyless — the singleton/resource shape (ADR-0024). This is how heterogeneous
- * ephemeral UI state (net status + latency, FPS/mem, wave timer, hovered hex) joins
- * the same reactive view as per-entity components: model it as components on a
- * reserved singleton entity (the flecs / Unity-DOTS "singleton-as-entity" model)
- * and read it through per-field channels — NOT a separate reactive-resource
- * subsystem. Resources stay non-reactive internal singletons.
- *
- * It reuses the entity-grain ADR-0013 component observer verbatim, filtered to the
- * one target eid: an `onSet` (or seed `onAdd`) republishes the entity's field values
- * into the struct via per-field setters. The per-field `Object.is` eq means an
- * unchanged field writes nothing — "equal write → 0 renders" — and per-field signals
- * give "1-of-N FIELD → 1 re-render"; drive with `batchedUpdate` for "one tick → one
- * commit". Because the component change-detection fires on `ctx.setField`, the
- * in-place write pattern that defeats a `setResource`-keyed resource observer is
- * handled for free.
- *
- * `fields` is explicit: a `ComponentDef` is a branded number at runtime (its schema
- * is a phantom type), so the field names must be passed — same contract as
- * `syncFieldsToMap`. Project a subset to channel only what the UI reads.
- *
- * A `reactiveStruct` has a fixed field set and no `delete`, so the map adapter's
- * delete-on-disable (#677 / ADR-0023) has no struct analog: `onRemove`/`onDisable`
- * **reset the fields to the channel's declared initial values** (`onSet` skips
- * disabled entities), `onEnable` republishes. The defaults are the channel's own
- * initials — the eager `into` struct's declared values (e.g. `NetStats.latency = -1`),
- * or the zeros of a freshly-created one — captured (untracked) at registration, NOT a
- * blind 0. A singleton is rarely despawned; this keeps the channel well-defined if it is.
- */
-export declare function syncSingletonToStruct<S extends ComponentSchema, const F extends readonly (string & keyof S)[]>(ecs: ECS, def: ComponentDef<S>, eid: EntityID, fields: F, opts?: SingletonSyncOptions<{
-    [K in F[number]]: number;
-}>): SingletonStructSync<{
-    [K in F[number]]: number;
-}>;
-export interface SingletonArraySync<T> {
-    /** The live ordered channel: a reader of slot `i` subscribes to that slot alone. */
-    readonly array: ReactiveArray<T>;
-    /** Unregister the observer and stop publishing. Safe to call more than once. */
-    dispose(): void;
-}
-export interface SingletonArraySyncOptions<T> {
-    access?: Partial<SystemAccessDeclaration>;
-    seedExisting?: boolean;
-    /** Drive a PRE-CREATED `reactiveArray` (the module-scope channel) instead of a fresh one. */
-    into?: ReactiveArray<T>;
-    /** Per-slot equality for the array's no-op skip (default `Object.is`). */
-    eq?: (a: T, b: T) => boolean;
-}
-/**
- * Sync ONE singleton entity's component into a `reactiveArray`, one slot per field
- * in `fields` order (#685 / ADR-0024) — the ORDERED sibling of `syncSingletonToStruct`,
- * for positional UI state (the army slots). On every change to the component it
- * `reconcile`s the array from the field values: a slot whose value is unchanged keeps
- * its reference (structural sharing), only changed slots wake. `onRemove`/`onDisable`
- * reset the slots to the channel's DECLARED initial slots (a reactiveArray has no row
- * delete) — captured (untracked) at registration, so the army channel resets to its
- * empty sentinel (`EMPTY_SLOT`), NOT a blind 0 that would read as unit type 0.
- *
- * `fields` is explicit (a `ComponentDef` is a branded number at runtime). Pair with
- * `@oasys/oecs/solid`'s `fromKernelArray` + a Solid `<Index>`.
- */
-export declare function syncSingletonToArray<S extends ComponentSchema>(ecs: ECS, def: ComponentDef<S>, eid: EntityID, fields: readonly (string & keyof S)[], opts?: SingletonArraySyncOptions<number>): SingletonArraySync<number>;
-/**
- * Advance the world one tick with every bridge publish coalesced into a single UI
- * flush. onAdd/onRemove fire mid-tick at flush boundaries and onSet fires at the
- * tick tail; wrapping the whole update in `batch` defers the effect flush until the
- * tick completes, so a frame that touched K entities (across any number of syncs on
- * this world) wakes its readers once, not once per observer dispatch point.
- * Equivalent to `batch(() => ecs.update(dt))`.
- */
-export declare function batchedUpdate(ecs: ECS, dt: number): void;
-//# sourceMappingURL=ecs_sync.d.ts.map

package/dist/extensions/reactive/ecs_sync.d.ts

@@ -1,214 +0,0 @@
-import { ReactiveArray, ReactiveMap, StructSetters, StructEq } from '../../reactive/index.js';
-import { ComponentDef, ComponentSchema, ECS, EntityID, SystemAccessDeclaration } from '../../core/ecs/index.js';
-import { shallow } from '../../reactive/shallow.js';
-export { shallow };
-/**
- * A read cursor over one entity's single-component state, handed to a single-
- * component `Projection`. `field` is column-backed under "column" grain
- * (sequential), random-access (`getField`) under "entity" grain.
- *
- * Lifetime: the cursor is a reused, mutable singleton valid ONLY during the
- * synchronous `project` call for the current row. Read what you need and return —
- * never capture `row` (or stash its `field` reads keyed off a later closure): the
- * next row/tick mutates it in place, so a captured cursor reads stale data.
- */
-export interface RowReader<S extends ComponentSchema> {
-    /** The current entity (the row being projected). */
-    readonly eid: EntityID;
-    /** Read a field of the synced component for the current row. */
-    field<K extends string & keyof S>(name: K): number;
-}
-/**
- * A read cursor over a JOINED entity (it carries every component in the join), for
- * a `JoinProjection`. `field(def, name)` reads any field of any joined component
- * for the current entity (random-access; the join subscribes to all of them so the
- * read can never go stale).
- *
- * Lifetime: like `RowReader`, a reused mutable singleton valid ONLY during the
- * synchronous `project` call — never capture it; the next dispatch mutates it.
- */
-export interface JoinReader<Schemas extends readonly ComponentSchema[] = readonly ComponentSchema[]> {
-    /** The current entity (it has all joined components). */
-    readonly eid: EntityID;
-    /** Read a field of one joined component for the current entity. `def` is
-     * constrained to the join's own component set — reading a def outside the
-     * join is the stale-read footgun the module header warns about (its changes
-     * aren't subscribed), so it's a compile error. */
-    field<S extends Schemas[number], K extends string & keyof S>(def: ComponentDef<S>, name: K): number;
-}
-/** Map one single-component row to the value a UI cell reads. */
-export type Projection<S extends ComponentSchema, V> = (row: RowReader<S>) => V;
-/** Map one joined entity to the value a UI cell reads. */
-export type JoinProjection<V, Schemas extends readonly ComponentSchema[] = readonly ComponentSchema[]> = (row: JoinReader<Schemas>) => V;
-/** Per-component dirty grain. See the module header for the measured crossover. */
-export type SyncGrain = "entity" | "column";
-export interface EcsMapSyncOptions<V> {
-    /** Dirty grain (default `"entity"`). Use `"column"` for high-churn components. */
-    grain?: SyncGrain;
-    /**
-     * Value equality for the map's per-key no-op skip (default `Object.is`). Pass
-     * `shallow` for object projections, or a content comparator. A fresh object
-     * every tick under the default reference eq wakes the row every frame.
-     */
-    eq?: (a: V, b: V) => boolean;
-    /**
-     * Access surface the projection touches, merged over the synced components'
-     * `reads`. `DEV` access-checks the observer callbacks exactly like a system.
-     */
-    access?: Partial<SystemAccessDeclaration>;
-    /**
-     * Replay current matches on registration (default `true`), so a bridge attached
-     * to an already-populated world seeds the map with present state instead of
-     * waking only on the next change. flecs `yieldExisting`.
-     */
-    seedExisting?: boolean;
-}
-export interface EcsMapSync<V> {
-    /** The live channel: a reader of key `eid` subscribes to that entity alone. */
-    readonly map: ReactiveMap<EntityID, V>;
-    /** Unregister the observer(s) and stop publishing. Safe to call more than once. */
-    dispose(): void;
-}
-/**
- * Sync ONE component's change detection into a `reactiveMap`, keyed by `EntityID`.
- * A value change publishes the changed rows; a spawn inserts a row and a despawn
- * deletes it. Returns the map + a disposer. Drive with `batchedUpdate(world, dt)`.
- *
- * To read more than one component per row, use `syncJoinToMap` — reading a second
- * component here goes stale (its changes aren't subscribed).
- */
-export declare function syncComponentToMap<S extends ComponentSchema, V>(ecs: ECS, def: ComponentDef<S>, project: Projection<S, V>, opts?: EcsMapSyncOptions<V>): EcsMapSync<V>;
-/**
- * Sugar over `syncComponentToMap`: project a fixed FIELD LIST into a `{ field:
- * value }` snapshot, with an automatic `shallow` eq so an unchanged row wakes
- * nobody. The declarative-field-list model from WatermelonDB `observeWithColumns` /
- * TanStack `select` — the common "mirror these fields" case without hand-writing
- * the projection + comparator.
- *
- * Allocation note: this builds a fresh object per dirty row and `shallow` does two
- * `Object.keys` per compare — fine for low-churn. For a HIGH-churn component (the
- * case you'd pick `grain:"column"` for), prefer `syncComponentToMap` with a scalar
- * or hand-written-`eq` projection, so the hot path doesn't allocate exactly where
- * the column grain is meant to keep it cheap.
- */
-export declare function syncFieldsToMap<S extends ComponentSchema, const F extends readonly (string & keyof S)[]>(ecs: ECS, def: ComponentDef<S>, fields: F, opts?: Omit<EcsMapSyncOptions<{
-    [K in F[number]]: number;
-}>, "eq">): EcsMapSync<{
-    [K in F[number]]: number;
-}>;
-/**
- * Sync a multi-component JOIN into a `reactiveMap`. An entity is a member iff it
- * has EVERY component in `defs`; the projection reads any of them via
- * `row.field(def, name)`. Change detection subscribes to ALL joined components, so
- * a write to ANY of them republishes the row — the join can never go stale (the
- * bug a single-component sync + manual secondary read would have). Spawns/removes
- * of any joined component re-evaluate membership.
- *
- * Entity grain only: a join spans archetypes, so there is no single column to
- * sweep. Drive with `batchedUpdate(world, dt)`.
- */
-export declare function syncJoinToMap<Schemas extends readonly ComponentSchema[], V>(ecs: ECS, defs: readonly [...{
-    [I in keyof Schemas]: ComponentDef<Schemas[I]>;
-}], project: JoinProjection<V, Schemas>, opts?: Omit<EcsMapSyncOptions<V>, "grain">): EcsMapSync<V>;
-export interface SingletonStructSync<V extends object> {
-    /** The live per-field channel: reading `struct.field` in a tracked scope
-     * subscribes to that field alone (pair with `fromKernelStruct` to render). */
-    readonly struct: V;
-    /** Unregister the observer and stop publishing. Safe to call more than once. */
-    dispose(): void;
-}
-export interface SingletonSyncOptions<V extends object = Record<string, number>> {
-    /**
-     * Access surface the publish touches, merged over the synced def's read.
-     * `DEV` access-checks the observer callbacks exactly like a system.
-     */
-    access?: Partial<SystemAccessDeclaration>;
-    /** Replay current state on registration (default `true`). flecs `yieldExisting`. */
-    seedExisting?: boolean;
-    /**
-     * Drive a PRE-CREATED `reactiveStruct` (its `[proxy, set]` pair) instead of
-     * creating a fresh one. Lets the consumer keep the struct at module scope as a
-     * stable "channel" with initial values present before the sync attaches (the
-     * client UI seam: panels import the eager proxy; the sync, set up at world build,
-     * republishes into it via the observer). The seed (`yieldExisting`) overwrites
-     * the eager initials with the entity's current values on registration.
-     */
-    into?: readonly [V, StructSetters<V>];
-    /** Per-field equality overrides for the created struct (parity with
-     * `SingletonArraySyncOptions.eq`). Ignored when `into` supplies a
-     * pre-created struct — that struct already carries its own `eq`. */
-    eq?: StructEq<V>;
-}
-/**
- * Sync ONE singleton entity's single-component state into a `reactiveStruct`,
- * keyless — the singleton/resource shape (ADR-0024). This is how heterogeneous
- * ephemeral UI state (net status + latency, FPS/mem, wave timer, hovered hex) joins
- * the same reactive view as per-entity components: model it as components on a
- * reserved singleton entity (the flecs / Unity-DOTS "singleton-as-entity" model)
- * and read it through per-field channels — NOT a separate reactive-resource
- * subsystem. Resources stay non-reactive internal singletons.
- *
- * It reuses the entity-grain ADR-0013 component observer verbatim, filtered to the
- * one target eid: an `onSet` (or seed `onAdd`) republishes the entity's field values
- * into the struct via per-field setters. The per-field `Object.is` eq means an
- * unchanged field writes nothing — "equal write → 0 renders" — and per-field signals
- * give "1-of-N FIELD → 1 re-render"; drive with `batchedUpdate` for "one tick → one
- * commit". Because the component change-detection fires on `ctx.setField`, the
- * in-place write pattern that defeats a `setResource`-keyed resource observer is
- * handled for free.
- *
- * `fields` is explicit: a `ComponentDef` is a branded number at runtime (its schema
- * is a phantom type), so the field names must be passed — same contract as
- * `syncFieldsToMap`. Project a subset to channel only what the UI reads.
- *
- * A `reactiveStruct` has a fixed field set and no `delete`, so the map adapter's
- * delete-on-disable (#677 / ADR-0023) has no struct analog: `onRemove`/`onDisable`
- * **reset the fields to the channel's declared initial values** (`onSet` skips
- * disabled entities), `onEnable` republishes. The defaults are the channel's own
- * initials — the eager `into` struct's declared values (e.g. `NetStats.latency = -1`),
- * or the zeros of a freshly-created one — captured (untracked) at registration, NOT a
- * blind 0. A singleton is rarely despawned; this keeps the channel well-defined if it is.
- */
-export declare function syncSingletonToStruct<S extends ComponentSchema, const F extends readonly (string & keyof S)[]>(ecs: ECS, def: ComponentDef<S>, eid: EntityID, fields: F, opts?: SingletonSyncOptions<{
-    [K in F[number]]: number;
-}>): SingletonStructSync<{
-    [K in F[number]]: number;
-}>;
-export interface SingletonArraySync<T> {
-    /** The live ordered channel: a reader of slot `i` subscribes to that slot alone. */
-    readonly array: ReactiveArray<T>;
-    /** Unregister the observer and stop publishing. Safe to call more than once. */
-    dispose(): void;
-}
-export interface SingletonArraySyncOptions<T> {
-    access?: Partial<SystemAccessDeclaration>;
-    seedExisting?: boolean;
-    /** Drive a PRE-CREATED `reactiveArray` (the module-scope channel) instead of a fresh one. */
-    into?: ReactiveArray<T>;
-    /** Per-slot equality for the array's no-op skip (default `Object.is`). */
-    eq?: (a: T, b: T) => boolean;
-}
-/**
- * Sync ONE singleton entity's component into a `reactiveArray`, one slot per field
- * in `fields` order (#685 / ADR-0024) — the ORDERED sibling of `syncSingletonToStruct`,
- * for positional UI state (the army slots). On every change to the component it
- * `reconcile`s the array from the field values: a slot whose value is unchanged keeps
- * its reference (structural sharing), only changed slots wake. `onRemove`/`onDisable`
- * reset the slots to the channel's DECLARED initial slots (a reactiveArray has no row
- * delete) — captured (untracked) at registration, so the army channel resets to its
- * empty sentinel (`EMPTY_SLOT`), NOT a blind 0 that would read as unit type 0.
- *
- * `fields` is explicit (a `ComponentDef` is a branded number at runtime). Pair with
- * `@oasys/oecs/solid`'s `fromKernelArray` + a Solid `<Index>`.
- */
-export declare function syncSingletonToArray<S extends ComponentSchema>(ecs: ECS, def: ComponentDef<S>, eid: EntityID, fields: readonly (string & keyof S)[], opts?: SingletonArraySyncOptions<number>): SingletonArraySync<number>;
-/**
- * Advance the world one tick with every bridge publish coalesced into a single UI
- * flush. onAdd/onRemove fire mid-tick at flush boundaries and onSet fires at the
- * tick tail; wrapping the whole update in `batch` defers the effect flush until the
- * tick completes, so a frame that touched K entities (across any number of syncs on
- * this world) wakes its readers once, not once per observer dispatch point.
- * Equivalent to `batch(() => ecs.update(dt))`.
- */
-export declare function batchedUpdate(ecs: ECS, dt: number): void;
-//# sourceMappingURL=ecs_sync.d.ts.map

package/dist/extensions/reactive/ecs_sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ecs_sync.d.ts","sourceRoot":"","sources":["../../../src/extensions/reactive/ecs_sync.ts"],"names":[],"mappings":"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"}

package/dist/extensions/reactive/index.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../../kernel-yWV3XnAb.cjs"),_=require("../../shallow-DQ8aG51_.cjs");class w{constructor(n){this.def=n}_ctx;_eid=0;get eid(){return this._eid}field(n){return this._ctx.getField(this._eid,this.def,n)}}class m{constructor(n){this.def=n}_eid=0;_row=0;cols=new Map;arch;bind(n){this.arch=n,this.cols.clear()}get eid(){return this._eid}field(n){let s=this.cols.get(n);return s===void 0&&(s=this.arch.getColumnRead(this.def,n),this.cols.set(n,s)),s[this._row]}}class v{_ctx;_eid=0;get eid(){return this._eid}field(n,s){return this._ctx.getField(this._eid,n,s)}}function p(l,n,s,r={}){const c=_.reactiveMap(r.eq),a={...r.access,reads:[n,...r.access?.reads??[]]},h=r.grain??"entity",u=r.seedExisting??!0,b=new w(n),y=(i,o)=>{o.isDisabled(i)||(b._ctx=o,b._eid=i,c.set(i,s(b)))};let g;return f.batch(()=>{if(h==="column"){const i=new m(n);g=l.observe(n,{granularity:"archetype",onSet:o=>{i.bind(o);const t=o.entityIds;for(let e=0;e<o.entityCount;e++)i._row=e,i._eid=t[e],c.set(i._eid,s(i))},onAdd:(o,t)=>y(o,t),onRemove:o=>c.delete(o),onDisable:o=>c.delete(o),onEnable:(o,t)=>y(o,t),access:a,yieldExisting:u})}else g=l.observe(n,{granularity:"entity",onSet:(i,o)=>y(i,o),onAdd:(i,o)=>y(i,o),onRemove:i=>c.delete(i),onDisable:i=>c.delete(i),onEnable:(i,o)=>y(i,o),access:a,yieldExisting:u})}),{map:c,dispose:()=>g.dispose()}}function E(l,n,s,r={}){return p(l,n,a=>{const h={};for(let u=0;u<s.length;u++)h[s[u]]=a.field(s[u]);return h},{...r,eq:_.shallow})}function S(l,n,s,r={}){const c=n,a=_.reactiveMap(r.eq),h={...r.access,reads:[...c,...r.access?.reads??[]]},u=r.seedExisting??!0,b=new v,y=(t,e)=>{for(let d=0;d<c.length;d++)if(!t.hasComponent(e,c[d]))return!1;return!0},g=(t,e)=>{e.isDisabled(t)||y(e,t)&&(b._ctx=e,b._eid=t,a.set(t,s(b)))},i=t=>{a.delete(t)};let o;return f.batch(()=>{o=c.map(t=>l.observe(t,{granularity:"entity",onSet:g,onAdd:g,onRemove:i,onDisable:i,onEnable:g,access:h,yieldExisting:u}))}),{map:a,dispose:()=>{for(let t=0;t<o.length;t++)o[t].dispose()}}}function R(l,n,s,r,c={}){const a={};for(let e=0;e<r.length;e++)a[r[e]]=0;const[h,u]=c.into??_.reactiveStruct(a,c.eq),b=f.untrack(()=>r.map(e=>h[e])),y={...c.access,reads:[n,...c.access?.reads??[]]},g=c.seedExisting??!0,i=e=>{for(let d=0;d<r.length;d++)u[r[d]](e.getField(s,n,r[d]))},o=()=>{for(let e=0;e<r.length;e++)u[r[e]](b[e])};let t;return f.batch(()=>{t=l.observe(n,{granularity:"entity",onSet:(e,d)=>{e===s&&i(d)},onAdd:(e,d)=>{e===s&&!d.isDisabled(s)&&i(d)},onRemove:e=>{e===s&&o()},onDisable:e=>{e===s&&o()},onEnable:(e,d)=>{e===s&&i(d)},access:y,yieldExisting:g})}),{struct:h,dispose:()=>t.dispose()}}function T(l,n,s,r,c={}){const a=c.into??_.reactiveArray(new Array(r.length).fill(0),c.eq),h=f.untrack(()=>a.snapshot());if(c.into!==void 0&&h.length!==r.length)throw new Error(`syncSingletonToArray: into.length (${h.length}) must equal fields.length (${r.length})`);const u={...c.access,reads:[n,...c.access?.reads??[]]},b=c.seedExisting??!0,y=new Array(r.length),g=t=>{for(let e=0;e<r.length;e++)y[e]=t.getField(s,n,r[e]);a.reconcile(y)},i=()=>a.reconcile(h);let o;return f.batch(()=>{o=l.observe(n,{granularity:"entity",onSet:(t,e)=>{t===s&&g(e)},onAdd:(t,e)=>{t===s&&!e.isDisabled(s)&&g(e)},onRemove:t=>{t===s&&i()},onDisable:t=>{t===s&&i()},onEnable:(t,e)=>{t===s&&g(e)},access:u,yieldExisting:b})}),{array:a,dispose:()=>o.dispose()}}function x(l,n){f.batch(()=>l.update(n))}exports.shallow=_.shallow;exports.batchedUpdate=x;exports.syncComponentToMap=p;exports.syncFieldsToMap=E;exports.syncJoinToMap=S;exports.syncSingletonToArray=T;exports.syncSingletonToStruct=R;

package/dist/extensions/reactive/index.d.cts

@@ -1,23 +0,0 @@
-/**
- * The production ECS→UI reactive bridge (#672 / ADR-0021).
- *
- * Drains the engine's own change detection (ADR-0013 component observers, riding
- * the ADR-0012 per-row dirty list) into a `reactiveMap` — publishing O(changed),
- * not O(all), each tick. Declarative selection + closure projection (the Bevy
- * `ExtractComponent` / WatermelonDB `observeWithColumns` shape):
- *   - `syncComponentToMap(def, project)` — one component, grain `"entity"`/`"column"`.
- *   - `syncFieldsToMap(def, [fields])` — field-list sugar with auto `shallow` eq.
- *   - `syncJoinToMap([defs], project)` — multi-component join (subscribes all defs).
- *
- * For singleton/ephemeral UI state (net status+latency, FPS/mem, wave timer), model
- * it as a component on a reserved singleton entity and read it keyless via per-field
- * channels (#687 / ADR-0024) — NOT a separate reactive-resource subsystem:
- *   - `syncSingletonToStruct(def, eid, [fields])` — one singleton entity → `reactiveStruct`.
- *   - `syncSingletonToArray(def, eid, [fields])` — one singleton entity → `reactiveArray` (ordered slots).
- *
- * The framework-agnostic counterpart to the Solid leaf: pair the map entry points
- * with `@oasys/oecs/solid`'s `fromKernelMap`, the singleton struct with
- * `fromKernelStruct`, and the singleton array with `fromKernelArray`, to render.
- */
-export { syncComponentToMap, syncFieldsToMap, syncJoinToMap, syncSingletonToStruct, syncSingletonToArray, batchedUpdate, shallow, type Projection, type JoinProjection, type RowReader, type JoinReader, type SyncGrain, type EcsMapSync, type EcsMapSyncOptions, type SingletonStructSync, type SingletonSyncOptions, type SingletonArraySync, type SingletonArraySyncOptions } from './ecs_sync.cjs';
-//# sourceMappingURL=index.d.ts.map

package/dist/extensions/reactive/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * The production ECS→UI reactive bridge (#672 / ADR-0021).
- *
- * Drains the engine's own change detection (ADR-0013 component observers, riding
- * the ADR-0012 per-row dirty list) into a `reactiveMap` — publishing O(changed),
- * not O(all), each tick. Declarative selection + closure projection (the Bevy
- * `ExtractComponent` / WatermelonDB `observeWithColumns` shape):
- *   - `syncComponentToMap(def, project)` — one component, grain `"entity"`/`"column"`.
- *   - `syncFieldsToMap(def, [fields])` — field-list sugar with auto `shallow` eq.
- *   - `syncJoinToMap([defs], project)` — multi-component join (subscribes all defs).
- *
- * For singleton/ephemeral UI state (net status+latency, FPS/mem, wave timer), model
- * it as a component on a reserved singleton entity and read it keyless via per-field
- * channels (#687 / ADR-0024) — NOT a separate reactive-resource subsystem:
- *   - `syncSingletonToStruct(def, eid, [fields])` — one singleton entity → `reactiveStruct`.
- *   - `syncSingletonToArray(def, eid, [fields])` — one singleton entity → `reactiveArray` (ordered slots).
- *
- * The framework-agnostic counterpart to the Solid leaf: pair the map entry points
- * with `@oasys/oecs/solid`'s `fromKernelMap`, the singleton struct with
- * `fromKernelStruct`, and the singleton array with `fromKernelArray`, to render.
- */
-export { syncComponentToMap, syncFieldsToMap, syncJoinToMap, syncSingletonToStruct, syncSingletonToArray, batchedUpdate, shallow, type Projection, type JoinProjection, type RowReader, type JoinReader, type SyncGrain, type EcsMapSync, type EcsMapSyncOptions, type SingletonStructSync, type SingletonSyncOptions, type SingletonArraySync, type SingletonArraySyncOptions } from './ecs_sync.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/extensions/reactive/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/reactive/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EACN,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,OAAO,EACP,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,MAAM,YAAY,CAAC"}

package/dist/extensions/reactive/index.development.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../../kernel-sw7ScKWu.cjs"),_=require("../../shallow-C5YmTbtb.cjs");class w{constructor(n){this.def=n}_ctx;_eid=0;get eid(){return this._eid}field(n){return this._ctx.getField(this._eid,this.def,n)}}class m{constructor(n){this.def=n}_eid=0;_row=0;cols=new Map;arch;bind(n){this.arch=n,this.cols.clear()}get eid(){return this._eid}field(n){let s=this.cols.get(n);return s===void 0&&(s=this.arch.getColumnRead(this.def,n),this.cols.set(n,s)),s[this._row]}}class v{_ctx;_eid=0;get eid(){return this._eid}field(n,s){return this._ctx.getField(this._eid,n,s)}}function p(l,n,s,r={}){const c=_.reactiveMap(r.eq),a={...r.access,reads:[n,...r.access?.reads??[]]},h=r.grain??"entity",u=r.seedExisting??!0,b=new w(n),y=(i,o)=>{o.isDisabled(i)||(b._ctx=o,b._eid=i,c.set(i,s(b)))};let g;return f.batch(()=>{if(h==="column"){const i=new m(n);g=l.observe(n,{granularity:"archetype",onSet:o=>{i.bind(o);const t=o.entityIds;for(let e=0;e<o.entityCount;e++)i._row=e,i._eid=t[e],c.set(i._eid,s(i))},onAdd:(o,t)=>y(o,t),onRemove:o=>c.delete(o),onDisable:o=>c.delete(o),onEnable:(o,t)=>y(o,t),access:a,yieldExisting:u})}else g=l.observe(n,{granularity:"entity",onSet:(i,o)=>y(i,o),onAdd:(i,o)=>y(i,o),onRemove:i=>c.delete(i),onDisable:i=>c.delete(i),onEnable:(i,o)=>y(i,o),access:a,yieldExisting:u})}),{map:c,dispose:()=>g.dispose()}}function E(l,n,s,r={}){return p(l,n,a=>{const h={};for(let u=0;u<s.length;u++)h[s[u]]=a.field(s[u]);return h},{...r,eq:_.shallow})}function S(l,n,s,r={}){const c=n,a=_.reactiveMap(r.eq),h={...r.access,reads:[...c,...r.access?.reads??[]]},u=r.seedExisting??!0,b=new v,y=(t,e)=>{for(let d=0;d<c.length;d++)if(!t.hasComponent(e,c[d]))return!1;return!0},g=(t,e)=>{e.isDisabled(t)||y(e,t)&&(b._ctx=e,b._eid=t,a.set(t,s(b)))},i=t=>{a.delete(t)};let o;return f.batch(()=>{o=c.map(t=>l.observe(t,{granularity:"entity",onSet:g,onAdd:g,onRemove:i,onDisable:i,onEnable:g,access:h,yieldExisting:u}))}),{map:a,dispose:()=>{for(let t=0;t<o.length;t++)o[t].dispose()}}}function R(l,n,s,r,c={}){const a={};for(let e=0;e<r.length;e++)a[r[e]]=0;const[h,u]=c.into??_.reactiveStruct(a,c.eq),b=f.untrack(()=>r.map(e=>h[e])),y={...c.access,reads:[n,...c.access?.reads??[]]},g=c.seedExisting??!0,i=e=>{for(let d=0;d<r.length;d++)u[r[d]](e.getField(s,n,r[d]))},o=()=>{for(let e=0;e<r.length;e++)u[r[e]](b[e])};let t;return f.batch(()=>{t=l.observe(n,{granularity:"entity",onSet:(e,d)=>{e===s&&i(d)},onAdd:(e,d)=>{e===s&&!d.isDisabled(s)&&i(d)},onRemove:e=>{e===s&&o()},onDisable:e=>{e===s&&o()},onEnable:(e,d)=>{e===s&&i(d)},access:y,yieldExisting:g})}),{struct:h,dispose:()=>t.dispose()}}function T(l,n,s,r,c={}){const a=c.into??_.reactiveArray(new Array(r.length).fill(0),c.eq),h=f.untrack(()=>a.snapshot());if(c.into!==void 0&&h.length!==r.length)throw new Error(`syncSingletonToArray: into.length (${h.length}) must equal fields.length (${r.length})`);const u={...c.access,reads:[n,...c.access?.reads??[]]},b=c.seedExisting??!0,y=new Array(r.length),g=t=>{for(let e=0;e<r.length;e++)y[e]=t.getField(s,n,r[e]);a.reconcile(y)},i=()=>a.reconcile(h);let o;return f.batch(()=>{o=l.observe(n,{granularity:"entity",onSet:(t,e)=>{t===s&&g(e)},onAdd:(t,e)=>{t===s&&!e.isDisabled(s)&&g(e)},onRemove:t=>{t===s&&i()},onDisable:t=>{t===s&&i()},onEnable:(t,e)=>{t===s&&g(e)},access:u,yieldExisting:b})}),{array:a,dispose:()=>o.dispose()}}function x(l,n){f.batch(()=>l.update(n))}exports.shallow=_.shallow;exports.batchedUpdate=x;exports.syncComponentToMap=p;exports.syncFieldsToMap=E;exports.syncJoinToMap=S;exports.syncSingletonToArray=T;exports.syncSingletonToStruct=R;