@nika-js/onlymap 0.1.0

package/dist/actions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The action registry (spec: "Module Breakdown / Behavior Engine" — "Action
+ * payload contract"). One event name maps to one action handler with one
+ * payload schema, honored identically across all three emit surfaces —
+ * `ctx.emit(name, payload)`, `data-emit`, and `<om-behavior>` — an action
+ * reads the same keys regardless of how it was triggered. `registerAction`
+ * is re-exported from the package entry point (index.ts) as the public
+ * `OmMap.registerAction` surface.
+ */
+import type { RuntimeCore } from "./runtime-core";
+import type { LayerIR } from "./ir";
+export type ActionHandler = (payload: Record<string, unknown>, mapEl: Element, core: RuntimeCore, layerIRs: ReadonlyMap<string, LayerIR>) => void;
+/** Is an action name registered? (Story/behavior validation — custom actions may register later, so absence is a warning, not an error.) */
+export declare function hasAction(name: string): boolean;
+export declare function registerAction(name: string, handler: ActionHandler): void;
+export declare function dispatchAction(name: string, payload: Record<string, unknown>, mapEl: Element, core: RuntimeCore, layerIRs?: ReadonlyMap<string, LayerIR>): void;
+/** Ids in this namespace are runtime-managed plumbing — excluded from ctx.layers (legend, layer-list, user widgets). */
+export declare const RUNTIME_INTERNAL_PREFIX = "__onlymapjs-";
+/** The overlay anchor for a feature: its bbox center for geojson geometry, else its point (flat lon/lat). */
+export declare function featureAnchorPoint(feature: unknown): [number, number] | undefined;
+/**
+ * `trace` — progressive draw. Real tracing needs per-vertex time, which is
+ * TripsLayer's whole purpose: sweep `currentTime` across the data's
+ * timestamp range through the per-frame channel. Other layer types fall
+ * back to `fade` with a warning (deck.gl has no dash-offset to fake a
+ * draw-on with — documented in the spec).
+ */
+export declare const TRACE_TEMP_PREFIX = "__onlymapjs-trace-";
+/** Story scrub restore — drop all trace hide bookkeeping for this core (the channel props themselves are cleared separately by cancelAllLayerEffects). */
+export declare function resetTraceHides(core: RuntimeCore): void;

package/dist/attribute-resolution.d.ts

@@ -0,0 +1,73 @@
+import type { LayerMeta, LayerFilter } from "./ir";
+import type { LayerSchema, PropDescriptor } from "./layer-registry";
+import type { Shape } from "./expr";
+/** Sweeps the shared caches down to exactly the keys still referenced by the current manifest (Q4). */
+export declare function sweepAccessorCache(liveKeys: ReadonlySet<string>): void;
+/**
+ * Reserved attributes whose FEATURE is design-only (spec'd, not built).
+ * Reserved-ness suppresses the unknown-attribute warning — which is exactly
+ * how the streaming attributes (`source`/`key`/`flush`) sat silently inert
+ * for weeks before implementation. This list turns a dead promise into a
+ * loud one: both the live resolver and the validator warn from it, and
+ * implementing the feature means deleting its entry here (the traceability
+ * table in the spec tracks the same state).
+ */
+export declare const INERT_RESERVED_ATTRS: Map<string, string>;
+/** Attributes with library-level meaning that never reach deck.gl as a prop. */
+export declare const RESERVED_ATTRS: Set<string>;
+/**
+ * Filtering (spec: "Filtering") is universal across every layer type — not
+ * tied to one schema's props like `pickable` — so it's resolved directly
+ * here rather than via `schema.props`, and excluded from the typo-check the
+ * same way `RESERVED_ATTRS` is. Single-field only (`filterSize`/`categorySize`
+ * fixed at 1); the spec's own example is single-field, and the "up to 4
+ * dimensions" case is a documented future extension.
+ */
+export declare const FILTER_ATTRS: Set<string>;
+/**
+ * Standard global HTML attributes an author (or the library itself, e.g.
+ * OmLayerElement setting `style.display = "none"`) may set for reasons
+ * unrelated to the layer schema. Never a typo signal.
+ */
+export declare const GLOBAL_HTML_ATTRS: Set<string>;
+/** Shared by the live typo-warning below and the standalone validator (validation.ts) — same signal, two surfaces. */
+export declare function isUnknownLayerAttr(attrName: string, schema: LayerSchema): boolean;
+/**
+ * `transition="get-fill-color 800ms, get-radius 400ms"` → deck.gl's
+ * `transitions` prop (GPU-interpolated per-prop animation — spec: "Map
+ * Stories / Animation primitives"). A deck SPECIAL prop invisible to
+ * defaultProps-derived schemas, so it's a universal library attribute like
+ * `label`/`color`. Prop names accept kebab or camel. Shared by the live
+ * resolver and the validator — same grammar, two surfaces.
+ */
+export declare function parseTransitionAttr(raw: string): {
+    transitions: Record<string, number>;
+    invalid: string[];
+};
+/**
+ * The js/unsafe-on-columnar rule, stated once for both surfaces (the
+ * isUnknownLayerAttr precedent): a full-JS accessor block is an opaque
+ * `d => ...` — there is no row object to hand it on a columnar layer, and
+ * materializing one per accessor call would silently forfeit the zero-copy
+ * path. Restricted accessors are fine: the compiler rewrites them to column
+ * access. The live resolver logs it and skips the block; the validator emits
+ * it as a structured error — same rule, guaranteed in sync.
+ */
+export declare const FULL_JS_COLUMNAR_RULE: {
+    applies: (isJs: boolean, shape: Shape) => boolean;
+    message: string;
+    fix: string;
+};
+/** Coerce a raw attribute string to a primitive: bare/true/false, JSON array/object, number, or string. */
+export declare function coerceValue(raw: string, hint?: PropDescriptor["type"], attrName?: string): unknown;
+export interface ResolvedAttributes {
+    props: Record<string, unknown>;
+    meta: LayerMeta;
+    /** deckProp -> fingerprint, to attach as the layer's `updateTriggers`. */
+    updateTriggers: Record<string, string>;
+    /** Every cache key this layer currently references — feeds the global mark-and-sweep. */
+    liveKeys: Set<string>;
+    /** The layer's active declarative filter, if `filter-field`/`filter-range` are present. */
+    filter?: LayerFilter;
+}
+export declare function resolveLayerAttributes(el: Element, schema: LayerSchema, shape: Shape): ResolvedAttributes;