@symbiote-native/engine 0.1.4 → 0.1.6

package/build/pan-responder/index.js

@@ -12,12 +12,10 @@
 // changed ones on `changedTouches`), so the centroid/velocity math here reads
 // those directly while keeping RN's accumulate-deltas-over-time behavior.
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 const SINGLE_TOUCH_COUNT = 1;
 // onShouldBlockNativeResponder defaults to true (RN: block native by default).
 const DEFAULT_BLOCK_NATIVE_RESPONDER = true;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function toFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }

package/build/permissions-android/index.js

@@ -19,6 +19,7 @@
 //   requestMultiplePermissions(permissions): Promise<{[permission]: string}>
 import { getNativeModule } from '../native-modules.js';
 import { dlog } from '../debug.js';
+import { isBoolean } from '../type-guards.js';
 // The native module name RN registers this TurboModule under
 // (`TurboModuleRegistry.get<Spec>('PermissionsAndroid')`). NOTE: a module name is
 // only provable on a real host (a headless fake answers to any name); this name
@@ -79,9 +80,6 @@ export const PERMISSIONS = Object.freeze({
     POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS',
     NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES',
 });
-function isBoolean(value) {
-    return typeof value === 'boolean';
-}
 // Narrow the native string result into a known RESULTS value. Any unrecognized
 // string is passed through as a IPermissionStatus only when it matches; otherwise
 // we fall back to DENIED: a runtime guard at the trust boundary, not an `as`.

package/build/{platform-color.d.ts → platform-color/index.d.ts}

@@ -17,3 +17,6 @@ export type IColorValue = string | IOpaqueColorValue;
 export declare function PlatformColor(...names: string[]): IOpaqueColorValue;
 export declare function DynamicColorIOS(tuple: IDynamicColorIOSTuple): IOpaqueColorValue;
 export declare function isOpaqueColorValue(value: unknown): value is IOpaqueColorValue;
+export declare function setColorProcessor(process: (value: IColorValue) => unknown): void;
+export declare function processColor(color: IColorValue): unknown;
+export declare function isProcessableColor(value: unknown): value is IColorValue;

package/build/platform-color/index.js

@@ -0,0 +1,49 @@
+// PlatformColor / DynamicColorIOS: opaque color values the native side resolves
+// (iOS UIColor: semantic system colors and appearance-aware light/dark tuples).
+// These are pure object constructors with no native dependency, so they live in
+// shared and every adapter re-exports them. The opaque shape ({ semantic } /
+// { dynamic }) is exactly what RN's processColor and the iOS RCTConvert UIColor
+// path read, so our commit-time color seam routes these objects through the
+// injected processor just like CSS-string colors (see commit.ts processValue).
+export function PlatformColor(...names) {
+    return { semantic: names };
+}
+export function DynamicColorIOS(tuple) {
+    return {
+        dynamic: {
+            light: tuple.light,
+            dark: tuple.dark,
+            highContrastLight: tuple.highContrastLight,
+            highContrastDark: tuple.highContrastDark,
+        },
+    };
+}
+// True for the opaque objects above: the color seam uses this to route them
+// through the platform processor alongside CSS-string colors.
+export function isOpaqueColorValue(value) {
+    return typeof value === 'object' && value !== null && ('semantic' in value || 'dynamic' in value);
+}
+// Color props must reach Fabric as platform ints, not CSS strings. Fabric's C++ color
+// parser silently drops strings. The actual conversion (processColor) is RN-platform-specific,
+// so it is injected here rather than imported, keeping shared free of a react-native dependency
+// (and the headless harness working). This module is the sole owner of "run a value through the
+// platform color processor" - every color-touching consumer (commit's fabricProps,
+// process-box-shadow, process-filter, process-background-image, StatusBar android) imports
+// processColor/isProcessableColor from here, never from commit.ts.
+let colorProcessor = value => value;
+export function setColorProcessor(process) {
+    colorProcessor = process;
+}
+// Public mirror of RN's processColor: run a color through the injected platform processor (the
+// canary wires RN's own). Off a real host it resolves CSS strings and opaque PlatformColor
+// objects to the platform ints Fabric expects; headless (no processor wired) it is the identity,
+// so smokes see the input unchanged.
+export function processColor(color) {
+    return colorProcessor(color);
+}
+// A color-keyed value the platform processor must convert before Fabric: a CSS string, or an
+// opaque PlatformColor / DynamicColorIOS object. Numbers (already platform ints) and undefined
+// are left untouched.
+export function isProcessableColor(value) {
+    return typeof value === 'string' || isOpaqueColorValue(value);
+}

package/build/process-background-image/index.js

@@ -1,15 +1,11 @@
 // JS-side port of RN's processBackgroundImage (Libraries/StyleSheet/processBackgroundImage.js).
 // Same root cause as boxShadow/filter/transform: `experimental_backgroundImage` registers with
 // enableNativeCSSParsing(), which DEFAULTS TO FALSE, so RN's stock path parses the CSS gradient
-// string / structured array in JS and sends only the processed array to native — Fabric's C++
+// string / structured array in JS and sends only the processed array to native - Fabric's C++
 // never sees the raw string. This restores that missing JS parse.
-//
-// processColor is referenced from ../commit at RUNTIME only (inside function bodies), never at
-// module-init, so the cyclic import (commit -> here -> commit) has no TDZ hazard — same pattern
-// as process-box-shadow/process-filter.
-import { processColor } from '../commit.js';
-import { isOpaqueColorValue } from '../platform-color.js';
+import { isOpaqueColorValue, processColor } from '../platform-color/index.js';
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 // RN processBackgroundImage.js: pre-compiled patterns.
 const NEWLINE_REGEX = /\n/g;
 const GRADIENT_REGEX = /^(linear|radial)-gradient\(((?:\([^)]*\)|[^()])*)\)/;
@@ -23,9 +19,6 @@ const LINEAR_GRADIENT_DEFAULT_DIRECTION = { type: 'angle', value: 180 };
 const DEFAULT_RADIAL_SHAPE = 'ellipse';
 const DEFAULT_RADIAL_SIZE = 'farthest-corner';
 const DEFAULT_RADIAL_POSITION = { top: '50%', left: '50%' };
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function isStringOrNumber(value) {
     return typeof value === 'string' || typeof value === 'number';
 }
@@ -221,7 +214,7 @@ function processBackgroundImageArray(rawList) {
 //#region CSS string form
 // Split a `background-image` value on its TOP-LEVEL commas only (multiple gradients, or a
 // color function's internal commas like `rgba(0, 0, 0, .3)`, must not be confused for one
-// another) — depth-tracking instead of a lookahead regex because a gradient's own arg list can
+// another) - depth-tracking instead of a lookahead regex because a gradient's own arg list can
 // itself contain nested parens (`linear-gradient(to right, rgba(0,0,0,.5), blue)`).
 function splitGradients(input) {
     const result = [];
@@ -320,7 +313,7 @@ function parseLinearGradientCSSString(gradientContent) {
 }
 // The `at <position>` clause of `radial-gradient(... at <position>, <color-stops>)`. Drains
 // `tokens` (the SAME queue the caller is walking) via `shift()`, mirroring RN's in-place mutation
-// of `firstPartTokens` — not a copy, so the caller sees it emptied after this returns.
+// of `firstPartTokens` - not a copy, so the caller sees it emptied after this returns.
 function parseRadialGradientPositionTokens(tokens) {
     if (tokens.length === 0)
         return null;
@@ -511,7 +504,7 @@ function parseRadialGradientCSSString(gradientContent) {
             position = parsedPosition;
             break;
         }
-        // No shape/size/position token found in this iteration — the rest of the first part is a
+        // No shape/size/position token found in this iteration - the rest of the first part is a
         // color stop, not gradient config.
         if (!hasShapeSizeOrPositionString)
             break;
@@ -545,7 +538,7 @@ function parseBackgroundImageCSSString(cssString) {
     return gradients;
 }
 //#endregion CSS string form
-// RN processBackgroundImage.js's default export. Returns [] on any invalid gradient — web
+// RN processBackgroundImage.js's default export. Returns [] on any invalid gradient - web
 // semantics: an invalid `background-image` paints none of it rather than a partial gradient.
 export function processBackgroundImage(backgroundImage) {
     if (backgroundImage == null)

package/build/process-box-shadow/index.js

@@ -4,11 +4,7 @@
 // processed array to native; Fabric's C++ never sees the raw string. symbiote was
 // forwarding the raw value, which native (CSS parsing off) silently ignores: shadow
 // rendered nothing. This restores the missing JS parse + per-color processColor.
-//
-// processColor is referenced from ./commit at RUNTIME only (inside the function bodies),
-// never at module-init, so the cyclic import (commit -> here -> commit) has no TDZ hazard.
-import { processColor } from '../commit.js';
-import { isOpaqueColorValue } from '../platform-color.js';
+import { isOpaqueColorValue, processColor } from '../platform-color/index.js';
 import { dlog } from '../debug.js';
 // RN processBoxShadow.js:16-19: split args only on the delimiters that are NOT inside
 // a parenthesized color like rgba(0,0,0,1).

package/build/process-filter.js

@@ -4,12 +4,9 @@
 // structured result. symbiote forwarded the raw value; the array form already worked
 // (Fabric accepts it raw, `filter:[{brightness:0.5}]` was device-verified), but the
 // CSS-string form and drop-shadow color processing were missing. This restores them.
-//
-// processColor is referenced from ./commit at RUNTIME only (inside function bodies),
-// never at module-init, so the cyclic import (commit -> here -> commit) has no TDZ hazard.
-import { processColor } from './commit.js';
-import { isOpaqueColorValue } from './platform-color.js';
+import { isOpaqueColorValue, processColor } from './platform-color/index.js';
 import { dlog } from './debug.js';
+import { isRecord } from './type-guards.js';
 // RN processFilter.js:19-24: pre-compiled patterns.
 const NEWLINE_REGEX = /\n/g;
 const FILTER_FUNCTION_REGEX = /([\w-]+)\(([^()]*|\([^()]*\)|[^()]*\([^()]*\)[^()]*)\)/g;
@@ -17,9 +14,6 @@ const ARGS_WITH_UNITS_REGEX = /([+-]?\d*(\.\d+)?)([a-zA-Z%]+)?/g;
 const WHITESPACE_SPLIT_REGEX = /\s+(?![^(]*\))/;
 const LENGTH_PARSE_REGEX = /([+-]?\d*(\.\d+)?)([\w\W]+)?/g;
 const RADIANS_TO_DEGREES = 180 / Math.PI;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // A length field may be a CSS string or a number; resolve to a number or null.
 function resolveLength(value) {
     if (typeof value === 'string')

package/build/registry.js

@@ -11,13 +11,14 @@
 // shared must stay react-native-free (the headless harness runs in plain Node), so
 // the ViewConfig lookup is INJECTED, exactly like the color processor: the adapter
 // wires `setNativeViewConfigSource(ReactNativeViewConfigRegistry.get)` on a real
-// host (on a real host that one source covers BOTH RN core and every library).
+// host, where that one source covers BOTH RN core and every library.
 //
 // The ONLY explicit list is OUR OWN built-in primitives (BUILTIN_COMPONENTS): a
 // finite set we own, which keep their hand-tuned tables (view-config events, commit
 // COLOR_PROPS) and are never read from the source, so they can't drift. Everything
 // NOT in that set derives. The list never grows with the community; it grows only
 // when we add a core primitive of our own.
+import { isRecord } from './type-guards.js';
 const EMPTY = { listeners: new Set(), byRaw: new Map(), processors: new Map() };
 // OUR own primitives: the finite set shared hand-tunes (view-config events,
 // commit COLOR_PROPS). The source is never consulted for these, so they can't
@@ -59,9 +60,6 @@ export function registerComponent(name, registration = {}) {
         list.push(registration);
     resolvedCache.delete(name);
 }
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // onChange -> change (mirrors node.ts listenerName; the split of the handler prop).
 function splitListener(handlerProp) {
     return handlerProp.charAt(2).toLowerCase() + handlerProp.slice(3);
@@ -92,7 +90,7 @@ function deriveFromConfig(config, into) {
             const attribute = validAttributes[key];
             if (isRecord(attribute)) {
                 const process = attribute.process;
-                // The codegen config already carries the right processor (processColor, …);
+                // The codegen config already carries the right processor (processColor, ...);
                 // wrap it so the typed Function becomes a PropProcessor without a cast.
                 if (typeof process === 'function')
                     into.processors.set(key, value => process(value));

package/build/settings/index.js

@@ -8,6 +8,7 @@
 import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
 import { getNativeModule } from '../native-modules.js';
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 // The iOS native module name RN registers this under. NOTE: this is the name the
 // iOS JS wrapper resolves via `TurboModuleRegistry.getEnforcing('SettingsManager')`.
 // The spec filename is `INativeSettingsManager`. A module name is only provable on a
@@ -19,9 +20,6 @@ const SETTINGS_UPDATED_EVENT = 'settingsUpdated';
 // watchIds are handed out as the registry index, so the first watcher is 0. A
 // cleared slot keeps its index (the array never shrinks) so later ids stay stable.
 const FIRST_WATCH_ID = 0;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // Lazily resolved so importing this module has no native side effect. `null` when
 // the module isn't linked (headless): the snapshot then starts empty and `set`
 // updates only JS state + fires watchers.

package/build/share/index.ios.js

@@ -6,8 +6,8 @@
 // web/headless.
 import { dlog } from '../debug.js';
 import { getNativeModule } from '../native-modules.js';
+import { ACTION_SHEET_MANAGER, } from '../action-sheet-ios/index.js';
 import { validateContent, shareActions, SHARED_ACTION, DISMISSED_ACTION } from './shared.js';
-const ACTION_SHEET_MANAGER = 'ActionSheetManager';
 export const Share = {
     ...shareActions,
     // Open the iOS share sheet for `content`. Resolves with the user's action

package/build/status-bar/index.android.js

@@ -11,8 +11,8 @@
 // relayout survives and the bar updates without blanking (verified on device: show/hide +
 // light/dark text). See render.ts's installStopSurfaceGlobal.
 import { getNativeModule } from '../native-modules.js';
-import { processColor } from '../commit.js';
 import { dlog } from '../debug.js';
+import { processColor } from '../platform-color/index.js';
 import { STATUS_BAR_MANAGER } from './shared.js';
 // processColor returns `unknown` (its result is platform-dependent); narrow to the
 // number Fabric/native expects, like RN's invariant before setColor. A non-number

package/build/style/index.js

@@ -7,9 +7,7 @@
 // POSITION only, never on a property VALUE. `transform: [{translateX: 5}]` is an
 // array-valued prop and `shadowOffset: {width, height}` an object-valued prop; both
 // are copied through untouched. Only the top-level style slot is flattened.
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from '../type-guards.js';
 export function flattenStyle(style) {
     if (Array.isArray(style)) {
         const result = {};
@@ -22,7 +20,7 @@ export function flattenStyle(style) {
         }
         return result;
     }
-    if (isPlainObject(style)) {
+    if (isRecord(style)) {
         // Shallow copy of own enumerable keys: values (arrays, nested objects) pass through.
         return { ...style };
     }

package/build/style-registry/index.d.ts

@@ -5,7 +5,5 @@ export declare function registerStyles(styles: Record<string, IResolvedStyle>):
 export declare function clearGlobalStyles(): void;
 export declare function isClassNameValue(value: unknown): value is IClassNameValue;
 export declare function resolveClassName(className: IClassNameValue): IResolvedStyle;
-export type IClassToggleMap = Record<string, boolean | undefined>;
-export type IScopableClassValue = string | IClassToggleMap | Array<string | IClassToggleMap> | undefined | null;
-export declare function scopeClassName(value: IScopableClassValue, localNames: ReadonlySet<string>, scopeId: string): IScopableClassValue;
+export declare function kebabToCamel(value: string): string;
 export {};

package/build/style-registry/index.js

@@ -1,17 +1,16 @@
 // Runtime style registry. Side-effect CSS imports (compiled by the sibling CSS-to-style
 // build package, not this module) call registerStyles() with camelCase keys; components
-// look them up by resolveClassName(). No CSS parsing happens here — this is a
-// Map<string, ...> lookup, nothing more.
+// look them up via resolveClassName(). No CSS parsing here - just a Map<string, ...> lookup.
 //
-// This registry has no Tailwind-utility detection layer — this repo's style surface has
-// no Tailwind layer, so the compound lookup below always runs for 2-4-part class strings
-// instead of being gated behind "no part looks like a utility class".
+// No Tailwind-utility detection layer: this repo's style surface has no Tailwind layer,
+// so the compound lookup below always runs for 2-4-part class strings instead of being
+// gated behind "no part looks like a utility class".
 //
 // kebab-case authoring: a CSS selector `.section-label` always registers under the
 // camelCase key `sectionLabel` (@symbiote-native/css-parser's extractClassName), so a template
-// can write EITHER `class="sectionLabel"` OR `class="section-label"` — resolveOne below
-// falls back to the kebab->camel form on a miss. The fallback matters because assuming
-// authors would always match the camelCase key exactly proved wrong in practice.
+// can write EITHER `class="sectionLabel"` OR `class="section-label"` - resolveOne below
+// falls back to the kebab->camel form on a miss, since authors don't reliably write the
+// exact camelCase key.
 // Compound lookup tries every ordering of 2-4 space-separated class parts joined by
 // '.' (e.g. "btn primary" -> "btn.primary" / "primary.btn") before falling back to a
 // per-class merge, mirroring CSS compound-selector registration (`.btn.primary { }`).
@@ -25,14 +24,14 @@ export function registerStyles(styles) {
         globalStyles.set(name, style);
     }
 }
-// Clears every registration; used between tests for isolation.
+// Used between tests to reset registry state.
 export function clearGlobalStyles() {
     globalStyles.clear();
 }
 // A `class`/`className` prop arrives as `unknown` at the routeProp boundary (any adapter can
 // hand over anything); this narrows before resolveClassName without an `as` cast. Shared with
 // adapters/vue/src/components/scroll-view/shared.ts's identical need, rather than each keeping
-// its own copy — that file imports this one instead of redeclaring it.
+// its own copy - that file imports this one instead of redeclaring it.
 export function isClassNameValue(value) {
     return typeof value === 'string' || (typeof value === 'object' && value !== null);
 }
@@ -101,10 +100,14 @@ function capitalize(value) {
 }
 // Duplicated from @symbiote-native/css-parser's identical helper rather than imported: css-parser
 // pulls in postcss and is build-time only (never shipped in the app bundle), and this registry
-// is the opposite — pure runtime, in every app bundle — so importing it here would leak a
+// is the opposite - pure runtime, in every app bundle - so importing it here would leak a
 // build-time dependency into the shipped app. The conversion itself is two lines; keeping both
 // copies in sync is a smaller cost than the alternative.
-function kebabToCamel(value) {
+//
+// Exported (not just local to this file) because ./scope.ts's Vue `<style scoped>` name
+// rewriter needs the same kebab->camel normalization and is a different responsibility living
+// in a sibling module - see that file's own doc comment for why it's split out of this one.
+export function kebabToCamel(value) {
     return value.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
 function tryCompoundLookup(parts) {
@@ -123,39 +126,3 @@ function resolveOne(name) {
         return {};
     return globalStyles.get(trimmed) ?? globalStyles.get(kebabToCamel(trimmed)) ?? {};
 }
-// Pure NAME rewriter for Vue `<style scoped>`: suffixes every class token that this
-// file's scoped block locally defines with `__${scopeId}`, leaving unrecognized tokens
-// (globals, external classes) untouched. Runs at the compiled call site BEFORE Vue's own
-// normalizeClass() collapses string/object/array `class` values to a final string, so it
-// must pre-process all three shapes normalizeClass understands. No registry lookup here —
-// resolveClassName still does the actual style lookup, unchanged, against the rewritten name.
-export function scopeClassName(value, localNames, scopeId) {
-    if (value === undefined || value === null)
-        return value;
-    if (Array.isArray(value)) {
-        return value.map(item => scopeClassEntry(item, localNames, scopeId));
-    }
-    return scopeClassEntry(value, localNames, scopeId);
-}
-// A token arrives as either the camelCase registry key (`sectionLabel`) or its kebab-case
-// authoring form (`section-label`) — normalize to camelCase FIRST, then decide scoping, so
-// `localNames` (always camelCase, built from the css-parser's registered keys) recognizes a
-// kebab-written token. The emitted (possibly suffixed) name is always the camelCase form.
-function scopeToken(token, localNames, scopeId) {
-    const camelToken = kebabToCamel(token);
-    return localNames.has(camelToken) ? `${camelToken}__${scopeId}` : camelToken;
-}
-function scopeClassEntry(value, localNames, scopeId) {
-    if (typeof value === 'object') {
-        const scoped = {};
-        for (const [name, enabled] of Object.entries(value)) {
-            scoped[scopeToken(name, localNames, scopeId)] = enabled;
-        }
-        return scoped;
-    }
-    return value
-        .split(/\s+/)
-        .filter(Boolean)
-        .map(token => scopeToken(token, localNames, scopeId))
-        .join(' ');
-}

package/build/style-registry/scope/index.d.ts

@@ -0,0 +1,3 @@
+export type IClassToggleMap = Record<string, boolean | undefined>;
+export type IScopableClassValue = string | IClassToggleMap | Array<string | IClassToggleMap> | undefined | null;
+export declare function scopeClassName(value: IScopableClassValue, localNames: ReadonlySet<string>, scopeId: string): IScopableClassValue;

package/build/style-registry/scope/index.js

@@ -0,0 +1,41 @@
+// Vue `<style scoped>` class-name rewriter. Distinct responsibility from the sibling
+// ./index.ts (the CSS class -> style registry): this module does pure NAME rewriting,
+// no registry lookup, no CSS parsing. It runs at the compiled call site of a Vue SFC's
+// scoped-style template - `adapters/vue/metro-vue-transformer.cjs` emits calls to
+// scopeClassName (imported there as `__scopeClass`) - BEFORE Vue's own normalizeClass()
+// collapses string/object/array `class` values to a final string, so it must pre-process
+// all three shapes normalizeClass understands. resolveClassName in ./index.ts still does
+// the actual style lookup, unchanged, against the rewritten (possibly suffixed) name.
+import { kebabToCamel } from '../index.js';
+// Suffixes every class token that this file's scoped block locally defines with
+// `__${scopeId}`, leaving unrecognized tokens (globals, external classes) untouched.
+export function scopeClassName(value, localNames, scopeId) {
+    if (value === undefined || value === null)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(item => scopeClassEntry(item, localNames, scopeId));
+    }
+    return scopeClassEntry(value, localNames, scopeId);
+}
+// A token arrives as either the camelCase registry key (`sectionLabel`) or its kebab-case
+// authoring form (`section-label`) - normalize to camelCase FIRST, then decide scoping, so
+// `localNames` (always camelCase, built from the css-parser's registered keys) recognizes a
+// kebab-written token. The emitted (possibly suffixed) name is always the camelCase form.
+function scopeToken(token, localNames, scopeId) {
+    const camelToken = kebabToCamel(token);
+    return localNames.has(camelToken) ? `${camelToken}__${scopeId}` : camelToken;
+}
+function scopeClassEntry(value, localNames, scopeId) {
+    if (typeof value === 'object') {
+        const scoped = {};
+        for (const [name, enabled] of Object.entries(value)) {
+            scoped[scopeToken(name, localNames, scopeId)] = enabled;
+        }
+        return scoped;
+    }
+    return value
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(token => scopeToken(token, localNames, scopeId))
+        .join(' ');
+}

package/build/style-registry/scope.d.ts

@@ -0,0 +1,3 @@
+export type IClassToggleMap = Record<string, boolean | undefined>;
+export type IScopableClassValue = string | IClassToggleMap | Array<string | IClassToggleMap> | undefined | null;
+export declare function scopeClassName(value: IScopableClassValue, localNames: ReadonlySet<string>, scopeId: string): IScopableClassValue;

package/build/style-registry/scope.js

@@ -0,0 +1,41 @@
+// Vue `<style scoped>` class-name rewriter. Distinct responsibility from the sibling
+// ./index.ts (the CSS class -> style registry): this module does pure NAME rewriting,
+// no registry lookup, no CSS parsing. It runs at the compiled call site of a Vue SFC's
+// scoped-style template - `adapters/vue/metro-vue-transformer.cjs` emits calls to
+// scopeClassName (imported there as `__scopeClass`) - BEFORE Vue's own normalizeClass()
+// collapses string/object/array `class` values to a final string, so it must pre-process
+// all three shapes normalizeClass understands. resolveClassName in ./index.ts still does
+// the actual style lookup, unchanged, against the rewritten (possibly suffixed) name.
+import { kebabToCamel } from './index.js';
+// Suffixes every class token that this file's scoped block locally defines with
+// `__${scopeId}`, leaving unrecognized tokens (globals, external classes) untouched.
+export function scopeClassName(value, localNames, scopeId) {
+    if (value === undefined || value === null)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(item => scopeClassEntry(item, localNames, scopeId));
+    }
+    return scopeClassEntry(value, localNames, scopeId);
+}
+// A token arrives as either the camelCase registry key (`sectionLabel`) or its kebab-case
+// authoring form (`section-label`) - normalize to camelCase FIRST, then decide scoping, so
+// `localNames` (always camelCase, built from the css-parser's registered keys) recognizes a
+// kebab-written token. The emitted (possibly suffixed) name is always the camelCase form.
+function scopeToken(token, localNames, scopeId) {
+    const camelToken = kebabToCamel(token);
+    return localNames.has(camelToken) ? `${camelToken}__${scopeId}` : camelToken;
+}
+function scopeClassEntry(value, localNames, scopeId) {
+    if (typeof value === 'object') {
+        const scoped = {};
+        for (const [name, enabled] of Object.entries(value)) {
+            scoped[scopeToken(name, localNames, scopeId)] = enabled;
+        }
+        return scoped;
+    }
+    return value
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(token => scopeToken(token, localNames, scopeId))
+        .join(' ');
+}

package/build/touch-history/index.d.ts

@@ -0,0 +1,23 @@
+interface ITouchRecord {
+    touchActive: boolean;
+    startPageX: number;
+    startPageY: number;
+    startTimeStamp: number;
+    currentPageX: number;
+    currentPageY: number;
+    currentTimeStamp: number;
+    previousPageX: number;
+    previousPageY: number;
+    previousTimeStamp: number;
+}
+interface ITouchHistory {
+    touchBank: ITouchRecord[];
+    numberActiveTouches: number;
+    indexOfSingleActiveTouch: number;
+    mostRecentTimeStamp: number;
+}
+export declare const touchHistory: ITouchHistory;
+export declare function recordTouchTrack(kind: 'start' | 'move' | 'end', nativeEvent: Record<string, unknown>): void;
+export declare function resetTouchHistory(): void;
+export declare function attachTouchHistory(nativeEvent: Record<string, unknown>): void;
+export {};