@tamagui/native-registry 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/types/specs/TamaguiRegistry.nitro.d.ts

@@ -0,0 +1,49 @@
+import type { HybridObject } from "react-native-nitro-modules";
+/**
+* Typed surface of the native registry.
+*
+* The engine is deliberately generic: it knows nothing about Tamagui themes
+* beyond "a named state per scope selects which slot props apply". Tamagui
+* semantics (theme names, scope wiring, compiler output) live in JS.
+*
+* Two methods are NOT in this spec because they take values Nitro cannot
+* type: `link(shadowNode, slots, scopeId) -> number` and internal raw-JSI
+* registration. They are registered as raw hybrid methods in C++ and typed
+* on the JS side in index.native.ts.
+*
+* Threading: every method must be called from the JS thread. The engine is
+* single-threaded by contract and holds no locks.
+*/
+export interface TamaguiRegistry extends HybridObject<{
+	ios: "c++";
+	android: "c++";
+}> {
+	/**
+	* Set the active state name for a scope ('' = root scope) and commit the
+	* matching slot props for every affected linked view in one ShadowTree
+	* transaction.
+	*/
+	setStateName(scopeId: string, stateName: string): void;
+	/** Read the active state name for a scope ('' = root). */
+	getStateName(scopeId: string): string;
+	/** Drop a scope entry (cleanup when a scope provider unmounts). */
+	removeScope(scopeId: string): void;
+	/** Unlink by the id returned from link(). Safe to call twice. */
+	unlink(id: number): void;
+	/** Number of currently linked views. */
+	getViewCount(): number;
+	/**
+	* Number of ShadowTree commits performed. Benchmark honesty counter: a
+	* measurement where this does not increase never exercised the fast path.
+	*/
+	getCommitCount(): number;
+	/**
+	* Number of linked views skipped during commits because their slots had no
+	* entry for the active state name. Always 0 when the compiler emitted
+	* exhaustive keys; anything else is an upstream bug, not a runtime
+	* condition to recover from.
+	*/
+	getMissCount(): number;
+}
+
+//# sourceMappingURL=TamaguiRegistry.nitro.d.ts.map

package/types/specs/TamaguiRegistry.nitro.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc,oBAAoB;;;;;;;;;;;;;;;;AAiBlC,iBAAiB,wBAAwB,aAAa;CAAE,KAAK;CAAO,SAAS;GAAS;;;;;;CAMpF,aAAa,iBAAiB;;CAG9B,aAAa;;CAGb,YAAY;;CAGZ,OAAO;;CAGP;;;;;CAMA;;;;;;;CAQA",
+  "names": [],
+  "sources": [
+    "src/specs/TamaguiRegistry.nitro.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type { HybridObject } from 'react-native-nitro-modules'\n\n/**\n * Typed surface of the native registry.\n *\n * The engine is deliberately generic: it knows nothing about Tamagui themes\n * beyond \"a named state per scope selects which slot props apply\". Tamagui\n * semantics (theme names, scope wiring, compiler output) live in JS.\n *\n * Two methods are NOT in this spec because they take values Nitro cannot\n * type: `link(shadowNode, slots, scopeId) -> number` and internal raw-JSI\n * registration. They are registered as raw hybrid methods in C++ and typed\n * on the JS side in index.native.ts.\n *\n * Threading: every method must be called from the JS thread. The engine is\n * single-threaded by contract and holds no locks.\n */\nexport interface TamaguiRegistry extends HybridObject<{ ios: 'c++'; android: 'c++' }> {\n  /**\n   * Set the active state name for a scope ('' = root scope) and commit the\n   * matching slot props for every affected linked view in one ShadowTree\n   * transaction.\n   */\n  setStateName(scopeId: string, stateName: string): void\n\n  /** Read the active state name for a scope ('' = root). */\n  getStateName(scopeId: string): string\n\n  /** Drop a scope entry (cleanup when a scope provider unmounts). */\n  removeScope(scopeId: string): void\n\n  /** Unlink by the id returned from link(). Safe to call twice. */\n  unlink(id: number): void\n\n  /** Number of currently linked views. */\n  getViewCount(): number\n\n  /**\n   * Number of ShadowTree commits performed. Benchmark honesty counter: a\n   * measurement where this does not increase never exercised the fast path.\n   */\n  getCommitCount(): number\n\n  /**\n   * Number of linked views skipped during commits because their slots had no\n   * entry for the active state name. Always 0 when the compiler emitted\n   * exhaustive keys; anything else is an upstream bug, not a runtime\n   * condition to recover from.\n   */\n  getMissCount(): number\n}\n"
+  ]
+}

package/types/types.d.ts

@@ -0,0 +1,61 @@
+/**
+* Slot props for one linked view.
+*
+* v1 implements two slot kinds: `base` (state-independent props, applied
+* under every state) and `state` (props keyed by state name, e.g. theme
+* name; the scope's active name selects which entry applies). Future kinds
+* (media, press, group, container) extend this shape; the engine merge
+* order is fixed: base, then state, then future kinds.
+*
+* Keys must be exhaustive for every state name the scope can take. The
+* engine does exact lookups only: no fallback chains, no name parsing. A
+* miss increments the engine's miss counter and is a bug in the emitter.
+*/
+export interface ViewSlots {
+	base?: Record<string, unknown>;
+	state?: Record<string, Record<string, unknown>>;
+}
+export interface RegistryStats {
+	viewCount: number;
+	commitCount: number;
+	missCount: number;
+}
+/** Returned by link(); call to unlink. Safe to call more than once. */
+export type Unlink = () => void;
+/**
+* Handle for a linked view. `id` addresses the view in batched per-view
+* operations (applyViewStates); `unlink` removes it. null when the ref had
+* no shadow node (never mounted) or the engine is unavailable (web).
+*/
+export interface LinkHandle {
+	id: number;
+	unlink: Unlink;
+}
+/**
+* One entry of a batched per-view state update. When `props` is present it
+* is merged into the view's state table under `state` first (lazy warm-up
+* for runtime integrations); the view's active state then becomes `state`
+* and all entries commit natively in one transaction.
+*/
+export interface ViewStateUpdate {
+	id: number;
+	state: string;
+	props?: Record<string, unknown>;
+}
+/** add or replace one resolved state-table entry without changing its view's controller */
+export interface ViewStateTableUpdate {
+	id: number;
+	state: string;
+	props: Record<string, unknown>;
+}
+/** Debug/test snapshot of a linked view's engine tables (getViewState). */
+export interface ViewStateSnapshot {
+	scopeId: string;
+	activeState: string;
+	base: Record<string, unknown> | null;
+	states: Record<string, Record<string, unknown>> | null;
+	/** the family's sticky nativeProps_DEPRECATED merge, null when unset */
+	nativeProps: Record<string, unknown> | null;
+}
+
+//# sourceMappingURL=types.d.ts.map

package/types/types.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": ";;;;;;;;;;;;;AAaA,iBAAiB,UAAU;CACzB,OAAO;CACP,QAAQ,eAAe;;AAGzB,iBAAiB,cAAc;CAC7B;CACA;CACA;;;AAIF,YAAY;;;;;;AAOZ,iBAAiB,WAAW;CAC1B;CACA,QAAQ;;;;;;;;AASV,iBAAiB,gBAAgB;CAC/B;CACA;CACA,QAAQ;;;AAIV,iBAAiB,qBAAqB;CACpC;CACA;CACA,OAAO;;;AAIT,iBAAiB,kBAAkB;CACjC;CACA;CACA,MAAM;CACN,QAAQ,eAAe;;CAEvB,aAAa",
+  "names": [],
+  "sources": [
+    "src/types.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "/**\n * Slot props for one linked view.\n *\n * v1 implements two slot kinds: `base` (state-independent props, applied\n * under every state) and `state` (props keyed by state name, e.g. theme\n * name; the scope's active name selects which entry applies). Future kinds\n * (media, press, group, container) extend this shape; the engine merge\n * order is fixed: base, then state, then future kinds.\n *\n * Keys must be exhaustive for every state name the scope can take. The\n * engine does exact lookups only: no fallback chains, no name parsing. A\n * miss increments the engine's miss counter and is a bug in the emitter.\n */\nexport interface ViewSlots {\n  base?: Record<string, unknown>\n  state?: Record<string, Record<string, unknown>>\n}\n\nexport interface RegistryStats {\n  viewCount: number\n  commitCount: number\n  missCount: number\n}\n\n/** Returned by link(); call to unlink. Safe to call more than once. */\nexport type Unlink = () => void\n\n/**\n * Handle for a linked view. `id` addresses the view in batched per-view\n * operations (applyViewStates); `unlink` removes it. null when the ref had\n * no shadow node (never mounted) or the engine is unavailable (web).\n */\nexport interface LinkHandle {\n  id: number\n  unlink: Unlink\n}\n\n/**\n * One entry of a batched per-view state update. When `props` is present it\n * is merged into the view's state table under `state` first (lazy warm-up\n * for runtime integrations); the view's active state then becomes `state`\n * and all entries commit natively in one transaction.\n */\nexport interface ViewStateUpdate {\n  id: number\n  state: string\n  props?: Record<string, unknown>\n}\n\n/** add or replace one resolved state-table entry without changing its view's controller */\nexport interface ViewStateTableUpdate {\n  id: number\n  state: string\n  props: Record<string, unknown>\n}\n\n/** Debug/test snapshot of a linked view's engine tables (getViewState). */\nexport interface ViewStateSnapshot {\n  scopeId: string\n  activeState: string\n  base: Record<string, unknown> | null\n  states: Record<string, Record<string, unknown>> | null\n  /** the family's sticky nativeProps_DEPRECATED merge, null when unset */\n  nativeProps: Record<string, unknown> | null\n}\n"
+  ]
+}