rnwind 0.0.1 → 0.0.3

package/lib/esm/metro/with-config.mjs

@@ -0,0 +1,194 @@
+import { mkdirSync, existsSync, watch, utimesSync } from 'node:fs';
+import path from 'node:path';
+import { writeDtsFile } from './dts.mjs';
+import { createRnwindResolver } from './resolver.mjs';
+import { configureRnwindState, getRnwindState, onThemeChange } from './state.mjs';
+
+/** Default cache directory at the project root. Visible for debugging. */
+const DEFAULT_CACHE_DIR = '.rnwind';
+/**
+ * Active CSS watcher — replaced (and the prior one closed) when
+ * `withRnwindConfig` is called again (Metro restart, repeated init).
+ * Only one watcher per process; no stacking.
+ */
+let activeCssWatcher = null;
+/**
+ * Watch the theme CSS for edits. On change, rewrite the per-scheme
+ * files with the fresh theme AND bump `mtime` on every source file
+ * rnwind has transformed so far — Metro's own watcher sees those
+ * mtime changes, invalidates the modules, and re-transforms them
+ * against the new CSS on the next request. `getCacheKey()` alone is
+ * NOT enough: Metro samples the cache key once per worker lifetime,
+ * so edits during an already-running dev server don't propagate
+ * without this explicit nudge.
+ * @param cssPath Absolute path to the theme CSS to watch.
+ * @param projectRoot Metro's project root (for `getRnwindState`).
+ */
+function watchThemeCss(cssPath, projectRoot) {
+    if (activeCssWatcher?.cssPath === cssPath)
+        return;
+    activeCssWatcher?.close();
+    if (!existsSync(cssPath))
+        return;
+    let pending = false;
+    const watcher = watch(cssPath, { persistent: false }, () => {
+        // Debounce: editors often emit 2-3 change events per save (atomic
+        // rename dance, tmp files). Coalesce to ONE rebuild per microtask.
+        if (pending)
+            return;
+        pending = true;
+        queueMicrotask(async () => {
+            pending = false;
+            try {
+                await onThemeChange(projectRoot);
+                touchRecordedFiles(projectRoot);
+            }
+            catch {
+                // Invalidation is best-effort — never crash the dev server.
+            }
+        });
+    });
+    activeCssWatcher = { cssPath, close: () => watcher.close() };
+}
+/**
+ * Bump the mtime on every file the builder has transformed. Metro's
+ * file watcher keys on `mtime`, so this is what makes it invalidate
+ * those modules and re-transform them.
+ * @param projectRoot Metro's project root.
+ */
+function touchRecordedFiles(projectRoot) {
+    const state = getRnwindState(projectRoot);
+    const files = state.builder.recordedFiles();
+    const now = new Date();
+    for (const file of files) {
+        try {
+            if (existsSync(file))
+                utimesSync(file, now, now);
+        }
+        catch {
+            // One file's stat failure shouldn't stop the others.
+        }
+    }
+}
+/**
+ * Where the rnwind babel transformer lives — resolved relative to this
+ * module so the path works from both the `src/` tree (tests) and the
+ * built `lib/` output. Tries a few extensions because `require.resolve`
+ * doesn't auto-find `.cjs` / `.mjs` from a bare specifier.
+ * @returns Absolute path to the rnwind transformer module.
+ */
+function transformerPath() {
+    for (const candidate of ['./transformer.cjs', './transformer.mjs', './transformer.js', './transformer.ts', './transformer']) {
+        try {
+            return require.resolve(candidate);
+        }
+        catch {
+            // try the next extension
+        }
+    }
+    throw new Error('rnwind: could not resolve the metro transformer path');
+}
+/**
+ * Resolve the effective cache directory, honoring a user override and
+ * falling back to `<projectRoot>/.rnwind`.
+ * @param projectRoot Anchor for relative paths.
+ * @param override User-supplied option.
+ * @returns Absolute cache directory.
+ */
+function resolveCacheDir(projectRoot, override) {
+    if (!override || override.length === 0)
+        return path.resolve(projectRoot, DEFAULT_CACHE_DIR);
+    return path.isAbsolute(override) ? override : path.resolve(projectRoot, override);
+}
+/**
+ * Read the theme CSS and extract `@variant <name>` blocks for the .d.ts
+ * generator. Forces construction of `getRnwindState`, then reads
+ * `parser.declaredSchemes` (populated synchronously at construction).
+ * @param cssEntry Absolute path to theme CSS.
+ * @param projectRoot
+ * @returns Scheme names (empty when the theme has no variants; `'base'` is filtered).
+ */
+function discoverSchemes(cssEntry, projectRoot) {
+    if (!existsSync(cssEntry))
+        return [];
+    try {
+        const { parser } = getRnwindState(projectRoot);
+        return parser.declaredSchemes.filter((name) => name !== 'base');
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Wrap a Metro config with rnwind's pipeline:
+ *  - Install the rnwind babel transformer.
+ *  - Chain a `resolveRequest` hook that serves
+ *    `rnwind/__generated/schemes` from `<cacheDir>/schemes.js`.
+ *  - Write the `.d.ts` so TypeScript accepts `className=` on RN components.
+ *  - Publish the theme CSS path + cache dir via env so Metro workers
+ *    can rebuild their local state.
+ *  - Ensure the cache dir is a watched folder Metro's haste-map indexes.
+ *
+ * Theme-edit hot reload happens implicitly: every transformed file
+ * imports `rnwind/__generated/schemes`, and that module eager-imports
+ * `common.style.js`. When the theme changes, the per-scheme files
+ * regenerate with new bytes; Metro's content SHA1 dedup detects the
+ * change and invalidates every importer automatically.
+ * `getCacheKey()` on the transformer covers the per-file transform
+ * cache. No file watcher / source-padding hack needed — the dep graph
+ * carries the signal.
+ * @param metroConfig Config from `getDefaultConfig(__dirname)` or equivalent.
+ * @param options rnwind options.
+ * @returns The same config, mutated.
+ */
+function withRnwindConfig(metroConfig, options) {
+    const projectRoot = options.projectRoot ?? metroConfig.projectRoot ?? process.cwd();
+    const cacheDir = resolveCacheDir(projectRoot, options.cacheDir);
+    const cssEntry = path.isAbsolute(options.cssEntryFile) ? options.cssEntryFile : path.resolve(projectRoot, options.cssEntryFile);
+    mkdirSync(cacheDir, { recursive: true });
+    const watchFolders = (metroConfig.watchFolders ?? []).filter((p) => typeof p === 'string' && p.length > 0);
+    configureRnwindState(cssEntry, cacheDir, watchFolders, options.classNamePrefixes, options.hostSources, options.hostComponents);
+    // Warm the state eagerly (in the Metro master process) so oxide's
+    // Scanner walks every project source (and every monorepo
+    // watch-folder) ONCE and the manifest + scheme files hold the
+    // complete union before Metro's resolver tries to SHA1 them on the
+    // first transform. Each worker lazy-repeats this scan on its first
+    // transform to converge on identical state.
+    try {
+        void getRnwindState(projectRoot).builder.ensureFilesExist();
+    }
+    catch {
+        // Any init error surfaces again at the first transform; don't crash Metro boot.
+    }
+    // Install transformer + resolver. Capture the existing
+    // babelTransformerPath BEFORE we override it — our worker chains to
+    // it (env-passed) so Flow / expo-router / babel-preset-expo etc. all
+    // continue to run.
+    const existingTransformerPath = metroConfig.transformer?.babelTransformerPath;
+    if (typeof existingTransformerPath === 'string' && existingTransformerPath.length > 0) {
+        process.env.RNWIND_UPSTREAM_TRANSFORMER = existingTransformerPath;
+    }
+    const upstream = metroConfig.resolver?.resolveRequest ?? null;
+    metroConfig.transformer = { ...metroConfig.transformer, babelTransformerPath: transformerPath() };
+    metroConfig.resolver = { ...metroConfig.resolver, resolveRequest: createRnwindResolver(upstream) };
+    // Metro's haste-map indexes `watchFolders` at startup. Adding the
+    // cache dir guarantees scheme style files + manifest get SHA1'd
+    // without a "Failed to get the SHA-1" race when the first transform
+    // writes them.
+    const existingWatch = metroConfig.watchFolders ?? [];
+    metroConfig.watchFolders = existingWatch.includes(cacheDir) ? existingWatch : [...existingWatch, cacheDir];
+    if (options.dtsFile !== false) {
+        const dtsPath = options.dtsFile ?? path.resolve(projectRoot, 'rnwind-types.d.ts');
+        const schemes = discoverSchemes(cssEntry, projectRoot);
+        writeDtsFile(dtsPath, schemes, options.classNamePrefixes);
+    }
+    // Watch the theme CSS. On edit, we rewrite scheme files AND touch
+    // mtime on every transformed source file so Metro invalidates them
+    // and re-transforms — the only reliable way to propagate theme
+    // changes to an already-running dev server.
+    watchThemeCss(cssEntry, projectRoot);
+    return metroConfig;
+}
+
+export { withRnwindConfig };
+//# sourceMappingURL=with-config.mjs.map

package/lib/esm/metro/with-config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-config.mjs","sources":["../../../../src/metro/with-config.ts"],"sourcesContent":["import { existsSync, mkdirSync, utimesSync, watch as watchFile } from 'node:fs'\nimport path from 'node:path'\nimport { writeDtsFile } from './dts'\nimport { createRnwindResolver, type ResolveRequestFn } from './resolver'\nimport { configureRnwindState, getRnwindState, onThemeChange } from './state'\n\n/** Default cache directory at the project root. Visible for debugging. */\nconst DEFAULT_CACHE_DIR = '.rnwind'\n\n/**\n * Active CSS watcher — replaced (and the prior one closed) when\n * `withRnwindConfig` is called again (Metro restart, repeated init).\n * Only one watcher per process; no stacking.\n */\nlet activeCssWatcher: { cssPath: string; close: () => void } | null = null\n\n/**\n * Watch the theme CSS for edits. On change, rewrite the per-scheme\n * files with the fresh theme AND bump `mtime` on every source file\n * rnwind has transformed so far — Metro's own watcher sees those\n * mtime changes, invalidates the modules, and re-transforms them\n * against the new CSS on the next request. `getCacheKey()` alone is\n * NOT enough: Metro samples the cache key once per worker lifetime,\n * so edits during an already-running dev server don't propagate\n * without this explicit nudge.\n * @param cssPath Absolute path to the theme CSS to watch.\n * @param projectRoot Metro's project root (for `getRnwindState`).\n */\nfunction watchThemeCss(cssPath: string, projectRoot: string): void {\n  if (activeCssWatcher?.cssPath === cssPath) return\n  activeCssWatcher?.close()\n  if (!existsSync(cssPath)) return\n  let pending = false\n  const watcher = watchFile(cssPath, { persistent: false }, () => {\n    // Debounce: editors often emit 2-3 change events per save (atomic\n    // rename dance, tmp files). Coalesce to ONE rebuild per microtask.\n    if (pending) return\n    pending = true\n    queueMicrotask(async () => {\n      pending = false\n      try {\n        await onThemeChange(projectRoot)\n        touchRecordedFiles(projectRoot)\n      } catch {\n        // Invalidation is best-effort — never crash the dev server.\n      }\n    })\n  })\n  activeCssWatcher = { cssPath, close: () => watcher.close() }\n}\n\n/**\n * Bump the mtime on every file the builder has transformed. Metro's\n * file watcher keys on `mtime`, so this is what makes it invalidate\n * those modules and re-transform them.\n * @param projectRoot Metro's project root.\n */\nfunction touchRecordedFiles(projectRoot: string): void {\n  const state = getRnwindState(projectRoot)\n  const files = state.builder.recordedFiles()\n  const now = new Date()\n  for (const file of files) {\n    try {\n      if (existsSync(file)) utimesSync(file, now, now)\n    } catch {\n      // One file's stat failure shouldn't stop the others.\n    }\n  }\n}\n\n/**\n * Where the rnwind babel transformer lives — resolved relative to this\n * module so the path works from both the `src/` tree (tests) and the\n * built `lib/` output. Tries a few extensions because `require.resolve`\n * doesn't auto-find `.cjs` / `.mjs` from a bare specifier.\n * @returns Absolute path to the rnwind transformer module.\n */\nfunction transformerPath(): string {\n  for (const candidate of ['./transformer.cjs', './transformer.mjs', './transformer.js', './transformer.ts', './transformer']) {\n    try {\n      return require.resolve(candidate)\n    } catch {\n      // try the next extension\n    }\n  }\n  throw new Error('rnwind: could not resolve the metro transformer path')\n}\n\n/**\n * Resolve the effective cache directory, honoring a user override and\n * falling back to `<projectRoot>/.rnwind`.\n * @param projectRoot Anchor for relative paths.\n * @param override User-supplied option.\n * @returns Absolute cache directory.\n */\nfunction resolveCacheDir(projectRoot: string, override: string | undefined): string {\n  if (!override || override.length === 0) return path.resolve(projectRoot, DEFAULT_CACHE_DIR)\n  return path.isAbsolute(override) ? override : path.resolve(projectRoot, override)\n}\n\n/**\n * Read the theme CSS and extract `@variant <name>` blocks for the .d.ts\n * generator. Forces construction of `getRnwindState`, then reads\n * `parser.declaredSchemes` (populated synchronously at construction).\n * @param cssEntry Absolute path to theme CSS.\n * @param projectRoot\n * @returns Scheme names (empty when the theme has no variants; `'base'` is filtered).\n */\nfunction discoverSchemes(cssEntry: string, projectRoot: string): readonly string[] {\n  if (!existsSync(cssEntry)) return []\n  try {\n    const { parser } = getRnwindState(projectRoot)\n    return parser.declaredSchemes.filter((name) => name !== 'base')\n  } catch {\n    return []\n  }\n}\n\n/** User-facing options for `withRnwindConfig`. */\nexport interface RnwindMetroOptions {\n  /** Path to the theme CSS (absolute or relative to `projectRoot`). Required. */\n  cssEntryFile: string\n  /** Where rnwind writes the `.d.ts` file. Set `false` to disable. Defaults to `<projectRoot>/rnwind-types.d.ts`. */\n  dtsFile?: string | false\n  /** Optional project-root override — defaults to `metroConfig.projectRoot` then `process.cwd()`. */\n  projectRoot?: string\n  /** Cache directory. Absolute, or relative to `projectRoot`. Default: `.rnwind` at project root. */\n  cacheDir?: string\n  /**\n   * Extra JSX prop-name prefixes that rnwind should rewrite. Each\n   * prefix `P` turns `<Tag PClassName=\"…\">` into `<Tag\n   * PStyle={lookupCss(…)}>`. The built-in `'contentContainer'` prefix\n   * is always on (covers ScrollView / FlatList / SectionList); user\n   * entries merge on top.\n   */\n  classNamePrefixes?: readonly string[]\n  /**\n   * Extra module specifiers whose JSX exports rnwind should treat as\n   * \"host components\" — i.e. tags whose `className=\"…\"` attribute is\n   * rewritten to `style={lookupCss(…)}` at build time (zero runtime\n   * cost). Merged with the built-in defaults: `react-native`,\n   * `react-native-reanimated`, `react-native-svg`,\n   * `react-native-gesture-handler`, `expo-linear-gradient`, `expo-image`.\n   *\n   * Anything NOT marked as a host has its `className` left untouched —\n   * the importing component receives the raw string and decides what\n   * to do with it. Use this option to opt your design-system / UI\n   * primitive packages into the zero-runtime path.\n   */\n  hostSources?: readonly string[]\n  /**\n   * Extra JSX tag names (verbatim — may include `.` for member access\n   * like `'Animated.View'`) rnwind should treat as host components,\n   * regardless of where they're imported from. Useful for one-off\n   * escape-hatches: `import { View as MyBox } from 'react-native'`\n   * doesn't change the local name → `'MyBox'` here picks it up.\n   */\n  hostComponents?: readonly string[]\n}\n\n/** Shape we mutate on Metro's config. Loose so we don't pin Metro's internal types. */\nexport interface MetroConfigLike {\n  projectRoot?: string\n  watchFolders?: string[]\n  transformer?: {\n    babelTransformerPath?: string\n    [key: string]: unknown\n  }\n  resolver?: {\n    resolveRequest?: ResolveRequestFn | null\n    [key: string]: unknown\n  }\n  [key: string]: unknown\n}\n\n/**\n * Wrap a Metro config with rnwind's pipeline:\n *  - Install the rnwind babel transformer.\n *  - Chain a `resolveRequest` hook that serves\n *    `rnwind/__generated/schemes` from `<cacheDir>/schemes.js`.\n *  - Write the `.d.ts` so TypeScript accepts `className=` on RN components.\n *  - Publish the theme CSS path + cache dir via env so Metro workers\n *    can rebuild their local state.\n *  - Ensure the cache dir is a watched folder Metro's haste-map indexes.\n *\n * Theme-edit hot reload happens implicitly: every transformed file\n * imports `rnwind/__generated/schemes`, and that module eager-imports\n * `common.style.js`. When the theme changes, the per-scheme files\n * regenerate with new bytes; Metro's content SHA1 dedup detects the\n * change and invalidates every importer automatically.\n * `getCacheKey()` on the transformer covers the per-file transform\n * cache. No file watcher / source-padding hack needed — the dep graph\n * carries the signal.\n * @param metroConfig Config from `getDefaultConfig(__dirname)` or equivalent.\n * @param options rnwind options.\n * @returns The same config, mutated.\n */\nexport function withRnwindConfig<C extends MetroConfigLike>(metroConfig: C, options: RnwindMetroOptions): C {\n  const projectRoot = options.projectRoot ?? metroConfig.projectRoot ?? process.cwd()\n  const cacheDir = resolveCacheDir(projectRoot, options.cacheDir)\n  const cssEntry = path.isAbsolute(options.cssEntryFile) ? options.cssEntryFile : path.resolve(projectRoot, options.cssEntryFile)\n\n  mkdirSync(cacheDir, { recursive: true })\n  const watchFolders = (metroConfig.watchFolders ?? []).filter((p) => typeof p === 'string' && p.length > 0)\n  configureRnwindState(cssEntry, cacheDir, watchFolders, options.classNamePrefixes, options.hostSources, options.hostComponents)\n\n  // Warm the state eagerly (in the Metro master process) so oxide's\n  // Scanner walks every project source (and every monorepo\n  // watch-folder) ONCE and the manifest + scheme files hold the\n  // complete union before Metro's resolver tries to SHA1 them on the\n  // first transform. Each worker lazy-repeats this scan on its first\n  // transform to converge on identical state.\n  try {\n    void getRnwindState(projectRoot).builder.ensureFilesExist()\n  } catch {\n    // Any init error surfaces again at the first transform; don't crash Metro boot.\n  }\n\n  // Install transformer + resolver. Capture the existing\n  // babelTransformerPath BEFORE we override it — our worker chains to\n  // it (env-passed) so Flow / expo-router / babel-preset-expo etc. all\n  // continue to run.\n  const existingTransformerPath = metroConfig.transformer?.babelTransformerPath\n  if (typeof existingTransformerPath === 'string' && existingTransformerPath.length > 0) {\n    process.env.RNWIND_UPSTREAM_TRANSFORMER = existingTransformerPath\n  }\n  const upstream = metroConfig.resolver?.resolveRequest ?? null\n  metroConfig.transformer = { ...metroConfig.transformer, babelTransformerPath: transformerPath() }\n  metroConfig.resolver = { ...metroConfig.resolver, resolveRequest: createRnwindResolver(upstream) }\n\n  // Metro's haste-map indexes `watchFolders` at startup. Adding the\n  // cache dir guarantees scheme style files + manifest get SHA1'd\n  // without a \"Failed to get the SHA-1\" race when the first transform\n  // writes them.\n  const existingWatch = metroConfig.watchFolders ?? []\n  metroConfig.watchFolders = existingWatch.includes(cacheDir) ? existingWatch : [...existingWatch, cacheDir]\n\n  if (options.dtsFile !== false) {\n    const dtsPath = options.dtsFile ?? path.resolve(projectRoot, 'rnwind-types.d.ts')\n    const schemes = discoverSchemes(cssEntry, projectRoot)\n    writeDtsFile(dtsPath, schemes, options.classNamePrefixes)\n  }\n\n  // Watch the theme CSS. On edit, we rewrite scheme files AND touch\n  // mtime on every transformed source file so Metro invalidates them\n  // and re-transforms — the only reliable way to propagate theme\n  // changes to an already-running dev server.\n  watchThemeCss(cssEntry, projectRoot)\n\n  return metroConfig\n}\n"],"names":["watchFile"],"mappings":"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"}

package/lib/esm/runtime/chain-handlers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Tiny helpers that compose rnwind's press / focus handlers with any
+ * user-provided ones the JSX site already has. The transformer uses
+ * these when it rewrites a `<Pressable onPressIn={user}>` into
+ * `<Pressable onPressIn={chainPress(user, _i.onPressIn)}>` so the user's
+ * callback keeps firing.
+ *
+ * Both helpers bail out when the user's handler is `null` / `undefined`,
+ * returning rnwind's handler directly — that gives the transformer a
+ * cheap uniform rewrite ("always chain") without allocating a new
+ * function per render when the user didn't opt in to the handler.
+ */
+import type { GestureResponderEvent, NativeSyntheticEvent, TargetedEvent } from 'react-native';
+type PressHandler = (event: GestureResponderEvent) => void;
+type FocusHandler = (event: NativeSyntheticEvent<TargetedEvent>) => void;
+/**
+ * Compose a user-supplied press handler with rnwind's internal one.
+ * User fires first (its return / side-effects happen pre-gate flip); the
+ * rnwind handler then updates the active flag.
+ * @param user User-supplied handler from the original JSX (optional).
+ * @param ours rnwind's internal active-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+export declare function chainPress(user: PressHandler | null | undefined, ours: PressHandler): PressHandler;
+/**
+ * Compose a user-supplied focus/blur handler with rnwind's internal one.
+ * Same ordering rule as {@link chainPress}: user first, rnwind second.
+ * @param user User-supplied handler (optional).
+ * @param ours rnwind's internal focus-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+export declare function chainFocus(user: FocusHandler | null | undefined, ours: FocusHandler): FocusHandler;
+export {};

package/lib/esm/runtime/chain-handlers.mjs

@@ -0,0 +1,34 @@
+/**
+ * Compose a user-supplied press handler with rnwind's internal one.
+ * User fires first (its return / side-effects happen pre-gate flip); the
+ * rnwind handler then updates the active flag.
+ * @param user User-supplied handler from the original JSX (optional).
+ * @param ours rnwind's internal active-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+function chainPress(user, ours) {
+    if (user == null)
+        return ours;
+    return (event) => {
+        user(event);
+        ours(event);
+    };
+}
+/**
+ * Compose a user-supplied focus/blur handler with rnwind's internal one.
+ * Same ordering rule as {@link chainPress}: user first, rnwind second.
+ * @param user User-supplied handler (optional).
+ * @param ours rnwind's internal focus-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+function chainFocus(user, ours) {
+    if (user == null)
+        return ours;
+    return (event) => {
+        user(event);
+        ours(event);
+    };
+}
+
+export { chainFocus, chainPress };
+//# sourceMappingURL=chain-handlers.mjs.map

package/lib/esm/runtime/chain-handlers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-handlers.mjs","sources":["../../../../src/runtime/chain-handlers.ts"],"sourcesContent":["/**\n * Tiny helpers that compose rnwind's press / focus handlers with any\n * user-provided ones the JSX site already has. The transformer uses\n * these when it rewrites a `<Pressable onPressIn={user}>` into\n * `<Pressable onPressIn={chainPress(user, _i.onPressIn)}>` so the user's\n * callback keeps firing.\n *\n * Both helpers bail out when the user's handler is `null` / `undefined`,\n * returning rnwind's handler directly — that gives the transformer a\n * cheap uniform rewrite (\"always chain\") without allocating a new\n * function per render when the user didn't opt in to the handler.\n */\nimport type { GestureResponderEvent, NativeSyntheticEvent, TargetedEvent } from 'react-native'\n\ntype PressHandler = (event: GestureResponderEvent) => void\ntype FocusHandler = (event: NativeSyntheticEvent<TargetedEvent>) => void\n\n/**\n * Compose a user-supplied press handler with rnwind's internal one.\n * User fires first (its return / side-effects happen pre-gate flip); the\n * rnwind handler then updates the active flag.\n * @param user User-supplied handler from the original JSX (optional).\n * @param ours rnwind's internal active-toggling handler.\n * @returns Combined handler, or `ours` directly when the user didn't provide one.\n */\nexport function chainPress(user: PressHandler | null | undefined, ours: PressHandler): PressHandler {\n  if (user == null) return ours\n  return (event: GestureResponderEvent): void => {\n    user(event)\n    ours(event)\n  }\n}\n\n/**\n * Compose a user-supplied focus/blur handler with rnwind's internal one.\n * Same ordering rule as {@link chainPress}: user first, rnwind second.\n * @param user User-supplied handler (optional).\n * @param ours rnwind's internal focus-toggling handler.\n * @returns Combined handler, or `ours` directly when the user didn't provide one.\n */\nexport function chainFocus(user: FocusHandler | null | undefined, ours: FocusHandler): FocusHandler {\n  if (user == null) return ours\n  return (event: NativeSyntheticEvent<TargetedEvent>): void => {\n    user(event)\n    ours(event)\n  }\n}\n"],"names":[],"mappings":"AAiBA;;;;;;;AAOG;AACG,SAAU,UAAU,CAAC,IAAqC,EAAE,IAAkB,EAAA;IAClF,IAAI,IAAI,IAAI,IAAI;AAAE,QAAA,OAAO,IAAI;IAC7B,OAAO,CAAC,KAA4B,KAAU;QAC5C,IAAI,CAAC,KAAK,CAAC;QACX,IAAI,CAAC,KAAK,CAAC;AACb,IAAA,CAAC;AACH;AAEA;;;;;;AAMG;AACG,SAAU,UAAU,CAAC,IAAqC,EAAE,IAAkB,EAAA;IAClF,IAAI,IAAI,IAAI,IAAI;AAAE,QAAA,OAAO,IAAI;IAC7B,OAAO,CAAC,KAA0C,KAAU;QAC1D,IAAI,CAAC,KAAK,CAAC;QACX,IAAI,CAAC,KAAK,CAAC;AACb,IAAA,CAAC;AACH;;;;"}

package/lib/esm/runtime/components/rnwind-provider.d.ts

@@ -0,0 +1,84 @@
+import { type ReactNode } from 'react';
+import type { ThemeTables } from '../../core/types';
+import type { Scheme } from '../types';
+import type { OnHaptics } from '../../core/parser/haptics';
+/**
+ * Per-render safe-area insets snapshot. Bridge from any source
+ * (`useSafeAreaInsets()`, expo-router insets, a manually computed
+ * value) into the {@link RnwindProvider} — rnwind stays
+ * library-agnostic.
+ */
+export type Insets = Readonly<{
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}>;
+/**
+ * Single value carried by the rnwind context. Every piece of runtime
+ * state rnwind needs — scheme, theme tables, insets, font scale,
+ * window width, active responsive breakpoint, optional haptic
+ * dispatcher — lives on this one bag. Consumers read it via
+ * {@link useRnwind} and either destructure or forward straight to
+ * `lookupCss` / `useCss`.
+ *
+ * `activeBreakpoint` is the highest-threshold registered breakpoint
+ * whose min-width is `<= windowWidth`, or `'base'` when below the
+ * smallest one (mobile-first tier) or when no breakpoints are
+ * registered yet (tests, bundles without rnwind-transformed sources).
+ * Always a string — never null. Reactive: it updates with
+ * `useWindowDimensions().width`, so consumers can branch on it
+ * without a separate hook.
+ */
+export type RnwindState = Readonly<{
+    scheme: Scheme;
+    tables: ThemeTables;
+    insets: Insets;
+    onHaptics: OnHaptics | undefined;
+    fontScale: number;
+    windowWidth: number;
+    activeBreakpoint: string;
+}>;
+/** Props accepted by {@link RnwindProvider}. */
+export type RnwindProviderProps = Readonly<{
+    scheme: Scheme;
+    tables?: ThemeTables;
+    insets?: Partial<Insets>;
+    onHaptics?: OnHaptics;
+    children?: ReactNode;
+}>;
+/**
+ * Read rnwind's full runtime state — scheme, theme tables, insets,
+ * fontScale, windowWidth, onHaptics — in one go. Pass the returned
+ * value straight to `lookupCss` / `useCss`, or destructure what you
+ * need.
+ * @returns Active rnwind state under the nearest {@link RnwindProvider}.
+ */
+export declare function useRnwind(): RnwindState;
+/**
+ * Internal context hook the babel transformer injects at the top of
+ * every rewritten component as `const _t = useR_()`. Same body as the
+ * public {@link useRnwind} — exposed under a `use*`-prefixed name so
+ * react-refresh's babel plugin (which only tracks call-sites whose
+ * identifier matches `^use[A-Z]`) folds it into each component's
+ * fast-refresh signature. Without that prefix the signature stayed
+ * stable across transformer changes; HMR then preserved fiber state
+ * while the rendered hook list shifted, surfacing as "change in the
+ * order of Hooks" runtime errors. Trailing underscore keeps it
+ * visually distinct from the user-facing `useRnwind`.
+ * @returns Active rnwind state.
+ */
+export declare function useR_(): RnwindState;
+/**
+ * Provider for rnwind's full runtime state. fontScale + windowWidth
+ * come from `useWindowDimensions()` so they react to OS-level
+ * orientation / accessibility-text-size changes automatically.
+ * @param props Provider props.
+ * @param props.scheme Active scheme name.
+ * @param props.tables Optional pre-resolved token tables.
+ * @param props.insets Optional safe-area insets.
+ * @param props.onHaptics Optional haptic dispatcher.
+ * @param props.children React subtree.
+ * @returns Provider element.
+ */
+export declare function RnwindProvider({ scheme, tables, insets, onHaptics, children }: RnwindProviderProps): ReactNode;

package/lib/esm/runtime/components/rnwind-provider.mjs

@@ -0,0 +1,94 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useMemo, useContext } from 'react';
+import { useWindowDimensions } from 'react-native';
+import { BASE_BREAKPOINT, loadScheme, activeBreakpointFor } from '../lookup-css.mjs';
+
+const EMPTY_TABLES = {};
+const ZERO_INSETS = { top: 0, right: 0, bottom: 0, left: 0 };
+const DEFAULT_STATE = {
+    scheme: 'light',
+    tables: EMPTY_TABLES,
+    insets: ZERO_INSETS,
+    onHaptics: undefined,
+    fontScale: 1,
+    windowWidth: 0,
+    activeBreakpoint: BASE_BREAKPOINT,
+};
+/**
+ * Normalise a `Partial<Insets>` into a complete {@link Insets}, returning
+ * the shared {@link ZERO_INSETS} reference when nothing is supplied so
+ * downstream memoisation stays stable.
+ * @param partial Caller-supplied insets (or undefined).
+ * @returns Complete insets record.
+ */
+function normaliseInsets(partial) {
+    if (!partial)
+        return ZERO_INSETS;
+    const top = partial.top ?? 0;
+    const right = partial.right ?? 0;
+    const bottom = partial.bottom ?? 0;
+    const left = partial.left ?? 0;
+    if (top === 0 && right === 0 && bottom === 0 && left === 0)
+        return ZERO_INSETS;
+    return { top, right, bottom, left };
+}
+/** Single internal context the runtime reads from. */
+const RnwindContext = createContext(DEFAULT_STATE);
+/**
+ * Read rnwind's full runtime state — scheme, theme tables, insets,
+ * fontScale, windowWidth, onHaptics — in one go. Pass the returned
+ * value straight to `lookupCss` / `useCss`, or destructure what you
+ * need.
+ * @returns Active rnwind state under the nearest {@link RnwindProvider}.
+ */
+function useRnwind() {
+    return useContext(RnwindContext);
+}
+/**
+ * Internal context hook the babel transformer injects at the top of
+ * every rewritten component as `const _t = useR_()`. Same body as the
+ * public {@link useRnwind} — exposed under a `use*`-prefixed name so
+ * react-refresh's babel plugin (which only tracks call-sites whose
+ * identifier matches `^use[A-Z]`) folds it into each component's
+ * fast-refresh signature. Without that prefix the signature stayed
+ * stable across transformer changes; HMR then preserved fiber state
+ * while the rendered hook list shifted, surfacing as "change in the
+ * order of Hooks" runtime errors. Trailing underscore keeps it
+ * visually distinct from the user-facing `useRnwind`.
+ * @returns Active rnwind state.
+ */
+function useR_() {
+    return useContext(RnwindContext);
+}
+/**
+ * Provider for rnwind's full runtime state. fontScale + windowWidth
+ * come from `useWindowDimensions()` so they react to OS-level
+ * orientation / accessibility-text-size changes automatically.
+ * @param props Provider props.
+ * @param props.scheme Active scheme name.
+ * @param props.tables Optional pre-resolved token tables.
+ * @param props.insets Optional safe-area insets.
+ * @param props.onHaptics Optional haptic dispatcher.
+ * @param props.children React subtree.
+ * @returns Provider element.
+ */
+function RnwindProvider({ scheme, tables, insets, onHaptics, children }) {
+    const normalized = normaliseInsets(insets);
+    const { fontScale, width } = useWindowDimensions();
+    const value = useMemo(() => {
+        loadScheme(scheme);
+        return {
+            scheme,
+            tables: tables ?? EMPTY_TABLES,
+            insets: normalized,
+            onHaptics,
+            fontScale,
+            windowWidth: width,
+            activeBreakpoint: activeBreakpointFor(width),
+        };
+    }, [scheme, tables, normalized, onHaptics, fontScale, width]);
+    return jsx(RnwindContext.Provider, { value: value, children: children });
+}
+
+export { RnwindProvider, useR_, useRnwind };
+//# sourceMappingURL=rnwind-provider.mjs.map

package/lib/esm/runtime/components/rnwind-provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rnwind-provider.mjs","sources":["../../../../../src/runtime/components/rnwind-provider.tsx"],"sourcesContent":["import { createContext, useContext, useMemo, type ReactNode } from 'react'\nimport { useWindowDimensions } from 'react-native'\nimport type { ThemeTables } from '../../core/types'\nimport type { Scheme } from '../types'\nimport type { OnHaptics } from '../../core/parser/haptics'\nimport { activeBreakpointFor, BASE_BREAKPOINT, loadScheme } from '../lookup-css'\n\n/**\n * Per-render safe-area insets snapshot. Bridge from any source\n * (`useSafeAreaInsets()`, expo-router insets, a manually computed\n * value) into the {@link RnwindProvider} — rnwind stays\n * library-agnostic.\n */\nexport type Insets = Readonly<{\n  top: number\n  right: number\n  bottom: number\n  left: number\n}>\n\n/**\n * Single value carried by the rnwind context. Every piece of runtime\n * state rnwind needs — scheme, theme tables, insets, font scale,\n * window width, active responsive breakpoint, optional haptic\n * dispatcher — lives on this one bag. Consumers read it via\n * {@link useRnwind} and either destructure or forward straight to\n * `lookupCss` / `useCss`.\n *\n * `activeBreakpoint` is the highest-threshold registered breakpoint\n * whose min-width is `<= windowWidth`, or `'base'` when below the\n * smallest one (mobile-first tier) or when no breakpoints are\n * registered yet (tests, bundles without rnwind-transformed sources).\n * Always a string — never null. Reactive: it updates with\n * `useWindowDimensions().width`, so consumers can branch on it\n * without a separate hook.\n */\nexport type RnwindState = Readonly<{\n  scheme: Scheme\n  tables: ThemeTables\n  insets: Insets\n  onHaptics: OnHaptics | undefined\n  fontScale: number\n  windowWidth: number\n  activeBreakpoint: string\n}>\n\n/** Props accepted by {@link RnwindProvider}. */\nexport type RnwindProviderProps = Readonly<{\n  scheme: Scheme\n  tables?: ThemeTables\n  insets?: Partial<Insets>\n  onHaptics?: OnHaptics\n  children?: ReactNode\n}>\n\nconst EMPTY_TABLES: ThemeTables = {}\nconst ZERO_INSETS: Insets = { top: 0, right: 0, bottom: 0, left: 0 }\nconst DEFAULT_STATE: RnwindState = {\n  scheme: 'light' as Scheme,\n  tables: EMPTY_TABLES,\n  insets: ZERO_INSETS,\n  onHaptics: undefined,\n  fontScale: 1,\n  windowWidth: 0,\n  activeBreakpoint: BASE_BREAKPOINT,\n}\n\n/**\n * Normalise a `Partial<Insets>` into a complete {@link Insets}, returning\n * the shared {@link ZERO_INSETS} reference when nothing is supplied so\n * downstream memoisation stays stable.\n * @param partial Caller-supplied insets (or undefined).\n * @returns Complete insets record.\n */\nfunction normaliseInsets(partial: Partial<Insets> | undefined): Insets {\n  if (!partial) return ZERO_INSETS\n  const top = partial.top ?? 0\n  const right = partial.right ?? 0\n  const bottom = partial.bottom ?? 0\n  const left = partial.left ?? 0\n  if (top === 0 && right === 0 && bottom === 0 && left === 0) return ZERO_INSETS\n  return { top, right, bottom, left }\n}\n\n/** Single internal context the runtime reads from. */\nconst RnwindContext = createContext<RnwindState>(DEFAULT_STATE)\n\n/**\n * Read rnwind's full runtime state — scheme, theme tables, insets,\n * fontScale, windowWidth, onHaptics — in one go. Pass the returned\n * value straight to `lookupCss` / `useCss`, or destructure what you\n * need.\n * @returns Active rnwind state under the nearest {@link RnwindProvider}.\n */\nexport function useRnwind(): RnwindState {\n  return useContext(RnwindContext)\n}\n\n/**\n * Internal context hook the babel transformer injects at the top of\n * every rewritten component as `const _t = useR_()`. Same body as the\n * public {@link useRnwind} — exposed under a `use*`-prefixed name so\n * react-refresh's babel plugin (which only tracks call-sites whose\n * identifier matches `^use[A-Z]`) folds it into each component's\n * fast-refresh signature. Without that prefix the signature stayed\n * stable across transformer changes; HMR then preserved fiber state\n * while the rendered hook list shifted, surfacing as \"change in the\n * order of Hooks\" runtime errors. Trailing underscore keeps it\n * visually distinct from the user-facing `useRnwind`.\n * @returns Active rnwind state.\n */\nexport function useR_(): RnwindState {\n  return useContext(RnwindContext)\n}\n\n/**\n * Provider for rnwind's full runtime state. fontScale + windowWidth\n * come from `useWindowDimensions()` so they react to OS-level\n * orientation / accessibility-text-size changes automatically.\n * @param props Provider props.\n * @param props.scheme Active scheme name.\n * @param props.tables Optional pre-resolved token tables.\n * @param props.insets Optional safe-area insets.\n * @param props.onHaptics Optional haptic dispatcher.\n * @param props.children React subtree.\n * @returns Provider element.\n */\nexport function RnwindProvider({ scheme, tables, insets, onHaptics, children }: RnwindProviderProps): ReactNode {\n  const normalized = normaliseInsets(insets)\n  const { fontScale, width } = useWindowDimensions()\n  const value = useMemo<RnwindState>(() => {\n    loadScheme(scheme)\n    return {\n      scheme,\n      tables: tables ?? EMPTY_TABLES,\n      insets: normalized,\n      onHaptics,\n      fontScale,\n      windowWidth: width,\n      activeBreakpoint: activeBreakpointFor(width),\n    }\n  }, [scheme, tables, normalized, onHaptics, fontScale, width])\n  return <RnwindContext.Provider value={value}>{children}</RnwindContext.Provider>\n}\n"],"names":["_jsx"],"mappings":";;;;;AAuDA,MAAM,YAAY,GAAgB,EAAE;AACpC,MAAM,WAAW,GAAW,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;AACpE,MAAM,aAAa,GAAgB;AACjC,IAAA,MAAM,EAAE,OAAiB;AACzB,IAAA,MAAM,EAAE,YAAY;AACpB,IAAA,MAAM,EAAE,WAAW;AACnB,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,WAAW,EAAE,CAAC;AACd,IAAA,gBAAgB,EAAE,eAAe;CAClC;AAED;;;;;;AAMG;AACH,SAAS,eAAe,CAAC,OAAoC,EAAA;AAC3D,IAAA,IAAI,CAAC,OAAO;AAAE,QAAA,OAAO,WAAW;AAChC,IAAA,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;AAC5B,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC;AAChC,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;AAClC,IAAA,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,CAAC;AAC9B,IAAA,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;AAAE,QAAA,OAAO,WAAW;IAC9E,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;AACrC;AAEA;AACA,MAAM,aAAa,GAAG,aAAa,CAAc,aAAa,CAAC;AAE/D;;;;;;AAMG;SACa,SAAS,GAAA;AACvB,IAAA,OAAO,UAAU,CAAC,aAAa,CAAC;AAClC;AAEA;;;;;;;;;;;;AAYG;SACa,KAAK,GAAA;AACnB,IAAA,OAAO,UAAU,CAAC,aAAa,CAAC;AAClC;AAEA;;;;;;;;;;;AAWG;AACG,SAAU,cAAc,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAuB,EAAA;AACjG,IAAA,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,mBAAmB,EAAE;AAClD,IAAA,MAAM,KAAK,GAAG,OAAO,CAAc,MAAK;QACtC,UAAU,CAAC,MAAM,CAAC;QAClB,OAAO;YACL,MAAM;YACN,MAAM,EAAE,MAAM,IAAI,YAAY;AAC9B,YAAA,MAAM,EAAE,UAAU;YAClB,SAAS;YACT,SAAS;AACT,YAAA,WAAW,EAAE,KAAK;AAClB,YAAA,gBAAgB,EAAE,mBAAmB,CAAC,KAAK,CAAC;SAC7C;AACH,IAAA,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC7D,OAAOA,GAAA,CAAC,aAAa,CAAC,QAAQ,EAAA,EAAC,KAAK,EAAE,KAAK,EAAA,QAAA,EAAG,QAAQ,EAAA,CAA0B;AAClF;;;;"}

package/lib/esm/runtime/gradient-types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Typed contract for the component rnwind's transformer calls with a
+ * gradient-class `className`. Matches `expo-linear-gradient` verbatim
+ * so users can plug any gradient library that mirrors that API.
+ *
+ * A typical wiring:
+ *
+ * ```tsx
+ * import { LinearGradient } from 'expo-linear-gradient'
+ * import type { AsLinearGradientProps } from 'rnwind'
+ *
+ * // Assert at the type level — CI catches mismatches before runtime.
+ * const _typeCheck: AsLinearGradientProps = {} as Parameters<typeof LinearGradient>[0]
+ *
+ * // Then use it in real JSX. rnwind fills in colors / start / end.
+ * <LinearGradient className="bg-gradient-to-r from-red-500 to-blue-500" />
+ * ```
+ *
+ * The rnwind transformer emits `colors` as a frozen `readonly string[]`,
+ * and `start` / `end` as frozen `{x: number, y: number}` records.
+ * Users pass the component; rnwind fills the props. Unused props
+ * (`locations`, `dither`, …) are forwarded verbatim from the JSX site.
+ */
+/** A unit-square point. Matches the `LinearGradientPoint` object form. */
+export interface LinearGradientPoint {
+    /** Horizontal component, 0..1. */
+    readonly x: number;
+    /** Vertical component, 0..1. */
+    readonly y: number;
+}
+/**
+ * The exact prop shape rnwind fills onto a gradient component at
+ * build time. A user-supplied `<LinearGradient>` (or any other
+ * component) must accept these props — no wrapper, no adapter.
+ */
+export interface AsLinearGradientProps {
+    /**
+     * Gradient colour stops in source order. rnwind emits a frozen
+     * `readonly string[]` with 2+ entries (at least `from` + `to`).
+     * Compatible with expo-linear-gradient's `colors: readonly [ColorValue, ColorValue, ...ColorValue[]]`.
+     */
+    readonly colors: readonly string[];
+    /**
+     * Start point, in the unit square (0,0)=top-left → (1,1)=bottom-right.
+     * rnwind emits a frozen `{x, y}` record matching the Tailwind
+     * direction utility (`to-r` → `{x: 0, y: 0.5}`).
+     */
+    readonly start: LinearGradientPoint;
+    /** End point — same unit-square coordinates as `start`. */
+    readonly end: LinearGradientPoint;
+    /**
+     * Optional colour-stop positions matching `colors` length. rnwind
+     * doesn't emit this today (Tailwind v4's stop-position atoms aren't
+     * wired yet); listed here so the prop surface still matches
+     * expo-linear-gradient when a consumer passes their own.
+     */
+    readonly locations?: readonly number[] | null;
+}

package/lib/esm/runtime/haptics.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Runtime helpers the transformer injects for haptic utilities.
+ *
+ * Two entry points:
+ *
+ *   useMountHaptic(requests) — fires each request on mount via
+ *     `useEffect(() => { ... }, [])`. Used by the transformer for bare
+ *     `haptic-*` atoms (no variant prefix).
+ *
+ *   triggerHaptic(onHaptics, request, trigger) — thin forwarding
+ *     helper for event-driven variants (`active:haptic-*`, `focus:...`,
+ *     `hover:...`). The transformer emits an inline arrow that calls
+ *     this from `onPressIn` / `onFocus` / etc.
+ *
+ * Both emit a one-shot dev-mode warning when `onHaptics` is missing —
+ * so developers get a clear "you forgot to wire <SchemeProvider
+ * onHaptics=...>" signal instead of silently dropping the haptic.
+ */
+import type { HapticRequest, HapticTrigger, OnHaptics } from '../core/parser/haptics';
+/**
+ * Test-only hook — clears the warned-haptics set so successive test
+ * runs don't silently swallow their own warnings.
+ */
+declare function __resetHapticWarnings(): void;
+/**
+ * Invoke every request in `requests` on mount (once per component
+ * mount), using the `onHaptics` dispatcher from the nearest
+ * `<SchemeProvider>`. Missing-provider dev warnings fire via
+ * {@link warnMissingOnHaptics}.
+ *
+ * Uses `useEffect(..., [])` — the requests array is identity-stable
+ * (hoisted at module scope by the transformer), so re-firing on
+ * re-renders isn't a concern.
+ * @param requests Hoisted request list for this component.
+ */
+declare function useMountHaptic(requests: readonly HapticRequest[]): void;
+/**
+ * Fire one haptic request through the provider dispatcher. Emits the
+ * missing-provider dev warning when no dispatcher is wired. Designed
+ * for the inline arrows the transformer synthesises:
+ *
+ *   onPressIn={(e) => { triggerHaptic(_h, _HR_xxx, 'pressIn'); user?.(e) }}
+ * @param onHaptics Provider dispatcher (may be undefined).
+ * @param request Pre-hoisted request object.
+ * @param trigger Lifecycle trigger.
+ */
+declare function triggerHaptic(onHaptics: OnHaptics | undefined, request: HapticRequest, trigger: HapticTrigger): void;
+export { useMountHaptic, triggerHaptic, __resetHapticWarnings };