react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/worklets-compat/index.js

@@ -0,0 +1,28 @@
+// react-native-gtkx/worklets — the `react-native-worklets` name, on a
+// platform with one thread.
+//
+// Reanimated 4 moved the worklet surface into its own package, and libraries
+// import it under that name rather than through Reanimated. That is not a
+// detail: `react-native-reanimated-dnd` 2.0.0 pulls `scheduleOnRN` and
+// `scheduleOnUI` out of it at module scope in five of its hooks
+// (useDraggable, useDroppable, useSortable, useHorizontalSortable,
+// useGridSortable) with no `try { require } catch` anywhere, so an unaliased
+// package name fails at IMPORT rather than at use. Aliasing
+// `react-native-reanimated` alone left that wall standing one package over.
+//
+// The surface itself already existed — this module adds the NAME. Both
+// presets alias the package onto it (src/vite/index.ts, src/metro/index.ts),
+// and the thread functions are the very same instance the Reanimated surface
+// exports, so `scheduleOnUI` reached through either package name queues into
+// one batch. Upstream has the same property for the same reason: Reanimated
+// re-exports them from here.
+//
+// What is implemented and what refuses is decided by upstream's own
+// non-native build rather than by us — see surface.ts, which is also where
+// everything that needs no clock lives so unit tests can reach it without
+// GTK. docs/api.md records the boundary.
+import { createWorkletsSurface } from "./surface";
+const { runOnUI, scheduleOnUI, runOnJS, scheduleOnRN, runOnUIAsync } = createWorkletsSurface();
+export { runOnJS, runOnUI, runOnUIAsync, scheduleOnRN, scheduleOnUI };
+export { callMicrotasks, createSerializable, createShareable, createSynchronizable, createWorkletRuntime, executeOnUIRuntimeSync, getDynamicFeatureFlag, getRuntimeKind, getStaticFeatureFlag, getUIRuntimeHolder, getUISchedulerHolder, isBundleModeEnabled, isRNRuntime, isSerializableRef, isShareable, isShareableRef, isSynchronizable, isUIRuntime, isWorkerRuntime, isWorkletFunction, isWorkletRuntime, makeShareable, makeShareableCloneOnUIRecursive, makeShareableCloneRecursive, registerCustomSerializable, runOnRuntime, runOnRuntimeAsync, runOnRuntimeAsyncWithId, runOnRuntimeSync, runOnRuntimeSyncWithId, RuntimeKind, runOnUISync, scheduleOnRuntime, scheduleOnRuntimeWithId, serializableMappingCache, setDynamicFeatureFlag, shareableMappingCache, toggleSlowAnimationsOnUIRuntime, UIRuntimeId, WorkletsModule, } from "./surface";
+//# sourceMappingURL=index.js.map

package/dist/worklets-compat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/worklets-compat/index.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,4BAA4B;AAC5B,EAAE;AACF,6EAA6E;AAC7E,0EAA0E;AAC1E,uEAAuE;AACvE,gEAAgE;AAChE,mEAAmE;AACnE,6EAA6E;AAC7E,4DAA4D;AAC5D,4EAA4E;AAC5E,EAAE;AACF,uEAAuE;AACvE,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,6BAA6B;AAC7B,EAAE;AACF,oEAAoE;AACpE,2EAA2E;AAC3E,0EAA0E;AAC1E,yCAAyC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA;AAEjD,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,GAClE,qBAAqB,EAAE,CAAA;AAEzB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,CAAA;AAErE,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,+BAA+B,EAC/B,2BAA2B,EAC3B,0BAA0B,EAC1B,YAAY,EACZ,iBAAiB,EACjB,uBAAuB,EACvB,gBAAgB,EAChB,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,+BAA+B,EAC/B,WAAW,EACX,cAAc,GACf,MAAM,WAAW,CAAA","sourcesContent":["// react-native-gtkx/worklets — the `react-native-worklets` name, on a\n// platform with one thread.\n//\n// Reanimated 4 moved the worklet surface into its own package, and libraries\n// import it under that name rather than through Reanimated. That is not a\n// detail: `react-native-reanimated-dnd` 2.0.0 pulls `scheduleOnRN` and\n// `scheduleOnUI` out of it at module scope in five of its hooks\n// (useDraggable, useDroppable, useSortable, useHorizontalSortable,\n// useGridSortable) with no `try { require } catch` anywhere, so an unaliased\n// package name fails at IMPORT rather than at use. Aliasing\n// `react-native-reanimated` alone left that wall standing one package over.\n//\n// The surface itself already existed — this module adds the NAME. Both\n// presets alias the package onto it (src/vite/index.ts, src/metro/index.ts),\n// and the thread functions are the very same instance the Reanimated surface\n// exports, so `scheduleOnUI` reached through either package name queues into\n// one batch. Upstream has the same property for the same reason: Reanimated\n// re-exports them from here.\n//\n// What is implemented and what refuses is decided by upstream's own\n// non-native build rather than by us — see surface.ts, which is also where\n// everything that needs no clock lives so unit tests can reach it without\n// GTK. docs/api.md records the boundary.\nimport { createWorkletsSurface } from \"./surface\"\n\nconst { runOnUI, scheduleOnUI, runOnJS, scheduleOnRN, runOnUIAsync } =\n  createWorkletsSurface()\n\nexport { runOnJS, runOnUI, runOnUIAsync, scheduleOnRN, scheduleOnUI }\n\nexport {\n  callMicrotasks,\n  createSerializable,\n  createShareable,\n  createSynchronizable,\n  createWorkletRuntime,\n  executeOnUIRuntimeSync,\n  getDynamicFeatureFlag,\n  getRuntimeKind,\n  getStaticFeatureFlag,\n  getUIRuntimeHolder,\n  getUISchedulerHolder,\n  isBundleModeEnabled,\n  isRNRuntime,\n  isSerializableRef,\n  isShareable,\n  isShareableRef,\n  isSynchronizable,\n  isUIRuntime,\n  isWorkerRuntime,\n  isWorkletFunction,\n  isWorkletRuntime,\n  makeShareable,\n  makeShareableCloneOnUIRecursive,\n  makeShareableCloneRecursive,\n  registerCustomSerializable,\n  runOnRuntime,\n  runOnRuntimeAsync,\n  runOnRuntimeAsyncWithId,\n  runOnRuntimeSync,\n  runOnRuntimeSyncWithId,\n  RuntimeKind,\n  runOnUISync,\n  scheduleOnRuntime,\n  scheduleOnRuntimeWithId,\n  serializableMappingCache,\n  setDynamicFeatureFlag,\n  shareableMappingCache,\n  toggleSlowAnimationsOnUIRuntime,\n  UIRuntimeId,\n  WorkletsModule,\n} from \"./surface\"\n\nexport type {\n  SerializableRef,\n  ShareableRef,\n  WorkletFunction,\n  WorkletRuntime,\n} from \"./surface\"\n"]}

package/dist/worklets-compat/surface.d.ts

@@ -0,0 +1,110 @@
+/** A function the Babel plugin processed. Never produced on this platform. */
+export type WorkletFunction<Args extends unknown[] = unknown[], ReturnValue = unknown> = ((...args: Args) => ReturnValue) & {
+    __workletHash?: number;
+};
+/** Upstream's handle for a runtime that cannot exist here — see the refusals. */
+export type WorkletRuntime = {
+    __workletRuntime: true;
+};
+/** Upstream's serializer handle. Identity here: nothing leaves this runtime. */
+export type SerializableRef<T = unknown> = T;
+/** @deprecated Upstream's former name for {@link SerializableRef}. */
+export type ShareableRef<T = unknown> = SerializableRef<T>;
+/**
+ * The thread surface. `runOnUI`/`runOnJS`/`scheduleOnUI`/`scheduleOnRN` come
+ * from the same `createThreads` the Reanimated surface uses — index.ts hands
+ * both modules the SAME instance, so a job queued through either name lands
+ * in the same batch, as it does upstream where one package re-exports the
+ * other.
+ */
+export declare const createWorkletsSurface: () => {
+    runOnUIAsync: <A extends unknown[], R>(worklet: (...args: A) => R, ...args: A) => Promise<R>;
+    runOnUI: <A extends unknown[]>(worklet: (...args: A) => unknown) => (...args: A) => void;
+    scheduleOnUI: <A extends unknown[]>(worklet: (...args: A) => unknown, ...args: A) => void;
+    runOnJS: <A extends unknown[]>(fn: (...args: A) => unknown) => (...args: A) => void;
+    scheduleOnRN: <A extends unknown[]>(fn: (...args: A) => unknown, ...args: A) => void;
+};
+export { isWorkletFunction } from "../reanimated-compat/threads";
+/**
+ * Upstream's runtime taxonomy. There is one runtime here and it is the React
+ * Native one — GTK's main loop IS the JS thread — which is exactly what
+ * upstream's non-native path reports too: its initializer sets
+ * `__RUNTIME_KIND` to `ReactNative` and never changes it.
+ */
+export declare enum RuntimeKind {
+    ReactNative = 1,
+    UI = 2,
+    Worker = 3
+}
+export declare const getRuntimeKind: () => RuntimeKind;
+export declare const isRNRuntime: () => boolean;
+export declare const isUIRuntime: () => boolean;
+export declare const isWorkerRuntime: () => boolean;
+export declare const isWorkletRuntime: () => boolean;
+/** Mirrored as data, as upstream's non-native `runtimes.ts` does. */
+export declare const UIRuntimeId: number;
+/**
+ * The serializer, which on a single-runtime path is a file of identity
+ * functions — a value never leaves the runtime it was made in, so there is
+ * nothing to clone and nothing to register.
+ */
+export declare const createSerializable: <T>(value: T) => SerializableRef<T>;
+export declare const isSerializableRef: (value: unknown) => boolean;
+export declare const registerCustomSerializable: (registration: unknown) => void;
+export declare const makeShareable: <T>(value: T) => T;
+export declare const makeShareableCloneRecursive: <T>(value: T) => SerializableRef<T>;
+export declare const makeShareableCloneOnUIRecursive: <T>(value: T) => SerializableRef<T>;
+/** @deprecated Upstream's former name for {@link isSerializableRef}. */
+export declare const isShareableRef: (value: unknown) => boolean;
+/** The mapping cache upstream keeps for the serializer, which has nothing to map. */
+export declare const serializableMappingCache: {
+    set(serializable: object, ref?: unknown): void;
+    get(key: object): unknown;
+};
+/** @deprecated Upstream's former name for {@link serializableMappingCache}. */
+export declare const shareableMappingCache: {
+    set(serializable: object, ref?: unknown): void;
+    get(key: object): unknown;
+};
+/** Deprecated and a documented no-op upstream, kept callable for source parity. */
+export declare const callMicrotasks: () => void;
+/** Structural checks, portable exactly as upstream writes them. */
+export declare const isShareable: (value: unknown) => boolean;
+export declare const isSynchronizable: (value: unknown) => boolean;
+/**
+ * Bundle mode is a Babel/Metro transform of upstream's own plugin, which this
+ * platform never runs — so the honest answer is upstream's non-native one.
+ */
+export declare const isBundleModeEnabled: () => boolean;
+/** A debug toggle for the UI runtime's clock, which is this platform's only clock. */
+export declare const toggleSlowAnimationsOnUIRuntime: () => boolean;
+/**
+ * Feature flags gate upstream's own native experiments. None of them exist
+ * here, so every flag reads false and setting one changes nothing — again
+ * upstream's non-native answer rather than an invention.
+ */
+export declare const getStaticFeatureFlag: (name: string) => boolean;
+export declare const getDynamicFeatureFlag: (name: string) => boolean;
+export declare const setDynamicFeatureFlag: (name: string, value: boolean) => void;
+export declare const createWorkletRuntime: any;
+export declare const runOnRuntime: any;
+export declare const runOnRuntimeAsync: any;
+export declare const runOnRuntimeAsyncWithId: any;
+export declare const runOnRuntimeSync: any;
+export declare const runOnRuntimeSyncWithId: any;
+export declare const scheduleOnRuntime: any;
+export declare const scheduleOnRuntimeWithId: any;
+export declare const getUIRuntimeHolder: any;
+export declare const getUISchedulerHolder: any;
+export declare const runOnUISync: any;
+export declare const executeOnUIRuntimeSync: any;
+export declare const createShareable: any;
+export declare const createSynchronizable: any;
+/**
+ * The TurboModule behind the whole package. Upstream's non-native build
+ * exports it as `null`, which fails as "cannot read properties of null" and
+ * names nothing; this refuses by name instead. The one deliberate deviation
+ * from the mirror rule above, and it can only ever turn a worse error into a
+ * better one — nothing that works against `null` works against a refusal.
+ */
+export declare const WorkletsModule: any;

package/dist/worklets-compat/surface.js

@@ -0,0 +1,153 @@
+// The pure half of the `react-native-worklets` mirror: the whole surface, and
+// the factory behind the thread functions.
+//
+// Split from index.ts because index.ts is the module both presets alias the
+// PACKAGE NAME onto, and a unit test wants the surface without the name. Every
+// export here is reachable from a machine with no GTK on it.
+//
+// THE RULE THIS FILE FOLLOWS, and it is the whole design: mirror upstream's
+// own NON-NATIVE implementation — the `.ts` files next to its `.native.ts`
+// ones, which are what react-native-windows and the web run. Where that file
+// computes something, this one computes the same thing; where it throws, this
+// one refuses by name. That is not a shortcut, it is the only boundary with a
+// source of truth: a worklet runtime is structural, and upstream agrees.
+// Measured against react-native-worklets 0.11.3.
+//
+// The one place that rule is deliberately NOT followed is HOW LATE a UI hop
+// lands: upstream's non-native build waits for a `requestAnimationFrame` and
+// this one does not. See reanimated-compat/threads.ts — the web's rAF stands
+// in for a UI runtime it has not got, React Native's real one does not wait
+// for a frame, and waiting here broke a measurement round trip.
+import { createThreads } from "../reanimated-compat/threads";
+import { createUnsupportedFactory } from "../unsupported-export";
+/**
+ * The thread surface. `runOnUI`/`runOnJS`/`scheduleOnUI`/`scheduleOnRN` come
+ * from the same `createThreads` the Reanimated surface uses — index.ts hands
+ * both modules the SAME instance, so a job queued through either name lands
+ * in the same batch, as it does upstream where one package re-exports the
+ * other.
+ */
+export const createWorkletsSurface = () => {
+    const threads = createThreads();
+    /**
+     * Upstream's `runOnUIAsync` resolves with the worklet's return value when
+     * the UI hop runs it — the one thread API that hands anything back, because
+     * a promise crosses the deferral the others impose.
+     */
+    const runOnUIAsync = (worklet, ...args) => new Promise((resolve) => {
+        threads.scheduleOnUI(() => {
+            resolve(worklet(...args));
+        });
+    });
+    return { ...threads, runOnUIAsync };
+};
+// --- the pure surface ----------------------------------------------------
+export { isWorkletFunction } from "../reanimated-compat/threads";
+/**
+ * Upstream's runtime taxonomy. There is one runtime here and it is the React
+ * Native one — GTK's main loop IS the JS thread — which is exactly what
+ * upstream's non-native path reports too: its initializer sets
+ * `__RUNTIME_KIND` to `ReactNative` and never changes it.
+ */
+export var RuntimeKind;
+(function (RuntimeKind) {
+    RuntimeKind[RuntimeKind["ReactNative"] = 1] = "ReactNative";
+    RuntimeKind[RuntimeKind["UI"] = 2] = "UI";
+    RuntimeKind[RuntimeKind["Worker"] = 3] = "Worker";
+})(RuntimeKind || (RuntimeKind = {}));
+export const getRuntimeKind = () => RuntimeKind.ReactNative;
+export const isRNRuntime = () => true;
+export const isUIRuntime = () => false;
+export const isWorkerRuntime = () => false;
+export const isWorkletRuntime = () => false;
+/** Mirrored as data, as upstream's non-native `runtimes.ts` does. */
+export const UIRuntimeId = RuntimeKind.UI;
+/**
+ * The serializer, which on a single-runtime path is a file of identity
+ * functions — a value never leaves the runtime it was made in, so there is
+ * nothing to clone and nothing to register.
+ */
+// The ones that ignore their argument are typed as a signature and
+// implemented without parameters: the CALL shape is what matters to a
+// consumer, and a named-but-unused parameter is only there to be linted.
+export const createSerializable = (value) => value;
+export const isSerializableRef = () => true;
+export const registerCustomSerializable = () => { };
+export const makeShareable = (value) => value;
+export const makeShareableCloneRecursive = (value) => value;
+export const makeShareableCloneOnUIRecursive = (value) => value;
+/** @deprecated Upstream's former name for {@link isSerializableRef}. */
+export const isShareableRef = isSerializableRef;
+/** The mapping cache upstream keeps for the serializer, which has nothing to map. */
+export const serializableMappingCache = {
+    set: () => { },
+    get: () => null,
+};
+/** @deprecated Upstream's former name for {@link serializableMappingCache}. */
+export const shareableMappingCache = serializableMappingCache;
+/** Deprecated and a documented no-op upstream, kept callable for source parity. */
+export const callMicrotasks = () => { };
+/** Structural checks, portable exactly as upstream writes them. */
+export const isShareable = (value) => typeof value === "object" &&
+    value !== null &&
+    !!value.__shareableRef;
+export const isSynchronizable = (value) => typeof value === "object" &&
+    value !== null &&
+    !!value.__synchronizableRef;
+/**
+ * Bundle mode is a Babel/Metro transform of upstream's own plugin, which this
+ * platform never runs — so the honest answer is upstream's non-native one.
+ */
+export const isBundleModeEnabled = () => false;
+/** A debug toggle for the UI runtime's clock, which is this platform's only clock. */
+export const toggleSlowAnimationsOnUIRuntime = () => false;
+/**
+ * Feature flags gate upstream's own native experiments. None of them exist
+ * here, so every flag reads false and setting one changes nothing — again
+ * upstream's non-native answer rather than an invention.
+ */
+export const getStaticFeatureFlag = () => false;
+export const getDynamicFeatureFlag = () => false;
+export const setDynamicFeatureFlag = () => { };
+// --- the refusals --------------------------------------------------------
+//
+// Exactly the exports whose non-native implementation upstream ships as a
+// `throw`. Enumerated by hand rather than produced by a Proxy over the module,
+// because ESM named imports resolve statically: a symbol missing from the
+// module fails at BUILD time with "no export named X", and only the names
+// here can produce the descriptive runtime message.
+const unsupported = createUnsupportedFactory("react-native-worklets", "Implemented here: runOnUI/scheduleOnUI/runOnJS/scheduleOnRN/runOnUIAsync, isWorkletFunction, " +
+    "the serializer (identity — nothing leaves this runtime) and the runtime-kind checks. " +
+    "What is not is a SECOND runtime: this platform has one thread, GTK's main loop, " +
+    "and upstream's own non-native build throws for these too. See docs/api.md.");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// --- a second runtime, which is structural by definition ---
+export const createWorkletRuntime = unsupported("createWorkletRuntime");
+export const runOnRuntime = unsupported("runOnRuntime");
+export const runOnRuntimeAsync = unsupported("runOnRuntimeAsync");
+export const runOnRuntimeAsyncWithId = unsupported("runOnRuntimeAsyncWithId");
+export const runOnRuntimeSync = unsupported("runOnRuntimeSync");
+export const runOnRuntimeSyncWithId = unsupported("runOnRuntimeSyncWithId");
+export const scheduleOnRuntime = unsupported("scheduleOnRuntime");
+export const scheduleOnRuntimeWithId = unsupported("scheduleOnRuntimeWithId");
+export const getUIRuntimeHolder = unsupported("getUIRuntimeHolder");
+export const getUISchedulerHolder = unsupported("getUISchedulerHolder");
+// --- synchronous hops across a boundary that is not there ---
+// Both are the "run it over there and give me the answer now" pair, and both
+// throw upstream on every single-runtime build. Deferring instead would be
+// worse than refusing: the caller wants the RETURN VALUE, and a deferred call
+// has none.
+export const runOnUISync = unsupported("runOnUISync");
+export const executeOnUIRuntimeSync = unsupported("executeOnUIRuntimeSync");
+// --- memory shared between runtimes ---
+export const createShareable = unsupported("createShareable");
+export const createSynchronizable = unsupported("createSynchronizable");
+/**
+ * The TurboModule behind the whole package. Upstream's non-native build
+ * exports it as `null`, which fails as "cannot read properties of null" and
+ * names nothing; this refuses by name instead. The one deliberate deviation
+ * from the mirror rule above, and it can only ever turn a worse error into a
+ * better one — nothing that works against `null` works against a refusal.
+ */
+export const WorkletsModule = unsupported("WorkletsModule");
+//# sourceMappingURL=surface.js.map

package/dist/worklets-compat/surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.js","sourceRoot":"","sources":["../../src/worklets-compat/surface.ts"],"names":[],"mappings":"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","sourcesContent":["// The pure half of the `react-native-worklets` mirror: the whole surface, and\n// the factory behind the thread functions.\n//\n// Split from index.ts because index.ts is the module both presets alias the\n// PACKAGE NAME onto, and a unit test wants the surface without the name. Every\n// export here is reachable from a machine with no GTK on it.\n//\n// THE RULE THIS FILE FOLLOWS, and it is the whole design: mirror upstream's\n// own NON-NATIVE implementation — the `.ts` files next to its `.native.ts`\n// ones, which are what react-native-windows and the web run. Where that file\n// computes something, this one computes the same thing; where it throws, this\n// one refuses by name. That is not a shortcut, it is the only boundary with a\n// source of truth: a worklet runtime is structural, and upstream agrees.\n// Measured against react-native-worklets 0.11.3.\n//\n// The one place that rule is deliberately NOT followed is HOW LATE a UI hop\n// lands: upstream's non-native build waits for a `requestAnimationFrame` and\n// this one does not. See reanimated-compat/threads.ts — the web's rAF stands\n// in for a UI runtime it has not got, React Native's real one does not wait\n// for a frame, and waiting here broke a measurement round trip.\nimport { createThreads } from \"../reanimated-compat/threads\"\nimport { createUnsupportedFactory } from \"../unsupported-export\"\n\n/** A function the Babel plugin processed. Never produced on this platform. */\nexport type WorkletFunction<\n  Args extends unknown[] = unknown[],\n  ReturnValue = unknown,\n> = ((...args: Args) => ReturnValue) & { __workletHash?: number }\n\n/** Upstream's handle for a runtime that cannot exist here — see the refusals. */\nexport type WorkletRuntime = { __workletRuntime: true }\n\n/** Upstream's serializer handle. Identity here: nothing leaves this runtime. */\nexport type SerializableRef<T = unknown> = T\n\n/** @deprecated Upstream's former name for {@link SerializableRef}. */\nexport type ShareableRef<T = unknown> = SerializableRef<T>\n\n/**\n * The thread surface. `runOnUI`/`runOnJS`/`scheduleOnUI`/`scheduleOnRN` come\n * from the same `createThreads` the Reanimated surface uses — index.ts hands\n * both modules the SAME instance, so a job queued through either name lands\n * in the same batch, as it does upstream where one package re-exports the\n * other.\n */\nexport const createWorkletsSurface = () => {\n  const threads = createThreads()\n\n  /**\n   * Upstream's `runOnUIAsync` resolves with the worklet's return value when\n   * the UI hop runs it — the one thread API that hands anything back, because\n   * a promise crosses the deferral the others impose.\n   */\n  const runOnUIAsync = <A extends unknown[], R>(\n    worklet: (...args: A) => R,\n    ...args: A\n  ): Promise<R> =>\n    new Promise<R>((resolve) => {\n      threads.scheduleOnUI(() => {\n        resolve(worklet(...args))\n      })\n    })\n\n  return { ...threads, runOnUIAsync }\n}\n\n// --- the pure surface ----------------------------------------------------\n\nexport { isWorkletFunction } from \"../reanimated-compat/threads\"\n\n/**\n * Upstream's runtime taxonomy. There is one runtime here and it is the React\n * Native one — GTK's main loop IS the JS thread — which is exactly what\n * upstream's non-native path reports too: its initializer sets\n * `__RUNTIME_KIND` to `ReactNative` and never changes it.\n */\nexport enum RuntimeKind {\n  ReactNative = 1,\n  UI = 2,\n  Worker = 3,\n}\n\nexport const getRuntimeKind = (): RuntimeKind => RuntimeKind.ReactNative\nexport const isRNRuntime = (): boolean => true\nexport const isUIRuntime = (): boolean => false\nexport const isWorkerRuntime = (): boolean => false\nexport const isWorkletRuntime = (): boolean => false\n\n/** Mirrored as data, as upstream's non-native `runtimes.ts` does. */\nexport const UIRuntimeId: number = RuntimeKind.UI\n\n/**\n * The serializer, which on a single-runtime path is a file of identity\n * functions — a value never leaves the runtime it was made in, so there is\n * nothing to clone and nothing to register.\n */\n// The ones that ignore their argument are typed as a signature and\n// implemented without parameters: the CALL shape is what matters to a\n// consumer, and a named-but-unused parameter is only there to be linted.\nexport const createSerializable = <T>(value: T): SerializableRef<T> => value\nexport const isSerializableRef: (value: unknown) => boolean = () => true\nexport const registerCustomSerializable: (\n  registration: unknown,\n) => void = () => {}\nexport const makeShareable = <T>(value: T): T => value\nexport const makeShareableCloneRecursive = <T>(value: T): SerializableRef<T> =>\n  value\nexport const makeShareableCloneOnUIRecursive = <T>(\n  value: T,\n): SerializableRef<T> => value\n/** @deprecated Upstream's former name for {@link isSerializableRef}. */\nexport const isShareableRef = isSerializableRef\n\n/** The mapping cache upstream keeps for the serializer, which has nothing to map. */\nexport const serializableMappingCache: {\n  set(serializable: object, ref?: unknown): void\n  get(key: object): unknown\n} = {\n  set: () => {},\n  get: () => null,\n}\n/** @deprecated Upstream's former name for {@link serializableMappingCache}. */\nexport const shareableMappingCache = serializableMappingCache\n\n/** Deprecated and a documented no-op upstream, kept callable for source parity. */\nexport const callMicrotasks = (): void => {}\n\n/** Structural checks, portable exactly as upstream writes them. */\nexport const isShareable = (value: unknown): boolean =>\n  typeof value === \"object\" &&\n  value !== null &&\n  !!(value as Record<string, unknown>).__shareableRef\n\nexport const isSynchronizable = (value: unknown): boolean =>\n  typeof value === \"object\" &&\n  value !== null &&\n  !!(value as Record<string, unknown>).__synchronizableRef\n\n/**\n * Bundle mode is a Babel/Metro transform of upstream's own plugin, which this\n * platform never runs — so the honest answer is upstream's non-native one.\n */\nexport const isBundleModeEnabled = (): boolean => false\n\n/** A debug toggle for the UI runtime's clock, which is this platform's only clock. */\nexport const toggleSlowAnimationsOnUIRuntime = (): boolean => false\n\n/**\n * Feature flags gate upstream's own native experiments. None of them exist\n * here, so every flag reads false and setting one changes nothing — again\n * upstream's non-native answer rather than an invention.\n */\nexport const getStaticFeatureFlag: (name: string) => boolean = () => false\nexport const getDynamicFeatureFlag: (name: string) => boolean = () => false\nexport const setDynamicFeatureFlag: (\n  name: string,\n  value: boolean,\n) => void = () => {}\n\n// --- the refusals --------------------------------------------------------\n//\n// Exactly the exports whose non-native implementation upstream ships as a\n// `throw`. Enumerated by hand rather than produced by a Proxy over the module,\n// because ESM named imports resolve statically: a symbol missing from the\n// module fails at BUILD time with \"no export named X\", and only the names\n// here can produce the descriptive runtime message.\n\nconst unsupported = createUnsupportedFactory(\n  \"react-native-worklets\",\n  \"Implemented here: runOnUI/scheduleOnUI/runOnJS/scheduleOnRN/runOnUIAsync, isWorkletFunction, \" +\n    \"the serializer (identity — nothing leaves this runtime) and the runtime-kind checks. \" +\n    \"What is not is a SECOND runtime: this platform has one thread, GTK's main loop, \" +\n    \"and upstream's own non-native build throws for these too. See docs/api.md.\",\n)\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n// --- a second runtime, which is structural by definition ---\nexport const createWorkletRuntime: any = unsupported(\"createWorkletRuntime\")\nexport const runOnRuntime: any = unsupported(\"runOnRuntime\")\nexport const runOnRuntimeAsync: any = unsupported(\"runOnRuntimeAsync\")\nexport const runOnRuntimeAsyncWithId: any = unsupported(\n  \"runOnRuntimeAsyncWithId\",\n)\nexport const runOnRuntimeSync: any = unsupported(\"runOnRuntimeSync\")\nexport const runOnRuntimeSyncWithId: any = unsupported(\"runOnRuntimeSyncWithId\")\nexport const scheduleOnRuntime: any = unsupported(\"scheduleOnRuntime\")\nexport const scheduleOnRuntimeWithId: any = unsupported(\n  \"scheduleOnRuntimeWithId\",\n)\nexport const getUIRuntimeHolder: any = unsupported(\"getUIRuntimeHolder\")\nexport const getUISchedulerHolder: any = unsupported(\"getUISchedulerHolder\")\n\n// --- synchronous hops across a boundary that is not there ---\n// Both are the \"run it over there and give me the answer now\" pair, and both\n// throw upstream on every single-runtime build. Deferring instead would be\n// worse than refusing: the caller wants the RETURN VALUE, and a deferred call\n// has none.\nexport const runOnUISync: any = unsupported(\"runOnUISync\")\nexport const executeOnUIRuntimeSync: any = unsupported(\"executeOnUIRuntimeSync\")\n\n// --- memory shared between runtimes ---\nexport const createShareable: any = unsupported(\"createShareable\")\nexport const createSynchronizable: any = unsupported(\"createSynchronizable\")\n\n/**\n * The TurboModule behind the whole package. Upstream's non-native build\n * exports it as `null`, which fails as \"cannot read properties of null\" and\n * names nothing; this refuses by name instead. The one deliberate deviation\n * from the mirror rule above, and it can only ever turn a worse error into a\n * better one — nothing that works against `null` works against a refusal.\n */\nexport const WorkletsModule: any = unsupported(\"WorkletsModule\")\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-gtkx",
-  "version": "0.2.0-alpha.2",
+  "version": "0.3.0-alpha.1",
   "description": "React Native components and APIs for Linux desktop, rendered as native GTK4 widgets via gtkx",
   "license": "MIT",
   "author": "Anton Petrov <anton@itsmepetrov.com>",
@@ -63,6 +63,22 @@
       "types": "./dist/common/index.d.ts",
       "default": "./dist/common/index.js"
     },
+    "./dnd": {
+      "types": "./dist/dnd/index.d.ts",
+      "default": "./dist/dnd/index.js"
+    },
+    "./gesture-handler": {
+      "types": "./dist/gesture-handler-compat/index.d.ts",
+      "default": "./dist/gesture-handler-compat/index.js"
+    },
+    "./reanimated": {
+      "types": "./dist/reanimated-compat/index.d.ts",
+      "default": "./dist/reanimated-compat/index.js"
+    },
+    "./worklets": {
+      "types": "./dist/worklets-compat/index.d.ts",
+      "default": "./dist/worklets-compat/index.js"
+    },
     "./mcp": {
       "types": "./dist/mcp/index.d.ts",
       "default": "./dist/mcp/index.js"
@@ -110,14 +126,14 @@
     }
   },
   "dependencies": {
-    "@gtkx/cli": "1.0.0-rc.3",
-    "@gtkx/codegen": "1.0.0-rc.3",
-    "@gtkx/config": "1.0.0-rc.3",
-    "@gtkx/css": "1.0.0-rc.3",
-    "@gtkx/react": "1.0.0-rc.3",
-    "@gtkx/runtime": "1.0.0-rc.3",
-    "@gtkx/testing": "1.0.0-rc.3",
-    "@gtkx/vitest": "1.0.0-rc.3",
+    "@gtkx/cli": "1.0.0-rc.4",
+    "@gtkx/codegen": "1.0.0-rc.4",
+    "@gtkx/config": "1.0.0-rc.4",
+    "@gtkx/css": "1.0.0-rc.4",
+    "@gtkx/react": "1.0.0-rc.4",
+    "@gtkx/runtime": "1.0.0-rc.4",
+    "@gtkx/testing": "1.0.0-rc.4",
+    "@gtkx/vitest": "1.0.0-rc.4",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "rolldown": "^1.1.5",
     "yoga-layout": "^3.2.1",

package/types.d.ts

@@ -48,8 +48,17 @@ declare module "react-native" {
   // OPTIONAL on purpose: an app sharing one component with ios/android
   // gets `undefined` there, and the type should say so — write
   // `hovered && styles.hovered`, which is correct on every platform.
+  //
+  // `focused` is here for the same reason and was missing: this platform
+  // reports it (GTK owns keyboard focus, and an activatable row draws
+  // Adwaita's focus ring from it — see docs/api.md), the stock type does
+  // not carry it, and an app that renders a focus ring in shared code had
+  // no way to name it. Found by moving `examples/tasks-nav`'s boxed list
+  // out of the platform package and into the app, where it stopped being
+  // typed by this package and started being typed by the stock types.
   interface PressableStateCallbackType {
     hovered?: boolean
+    focused?: boolean
   }
 }
 

package/dist/common/list.d.ts

@@ -1,82 +0,0 @@
-import { type ReactNode } from "react";
-import type { StyleProp } from "../contracts";
-/**
- * Where a row sits in its list, which is what decides its corner radii and
- * whether it draws a separator under itself.
- *
- * RN has no `:first-child`, so this is explicit. From a `FlatList` it is
- * `rowPosition(index, data.length)`; from a static list it is the same
- * expression over the array.
- */
-export type ListRowPosition = "first" | "middle" | "last" | "only";
-/** The usual derivation, so no call site has to get the one-row case wrong. */
-export declare const rowPosition: (index: number, count: number) => ListRowPosition;
-export type ListProps = {
-    children?: ReactNode;
-    style?: StyleProp;
-    testID?: string;
-};
-/**
- * The `.boxed-list` frame: a rounded, shadowed card. Put `ListRow`s in it
- * directly, or a `FlatList` whose `renderItem` returns them.
- *
- * ```tsx
- * <List>
- *   {tasks.map((task, index) => (
- *     <ListRow
- *       key={task.id}
- *       title={task.title}
- *       position={rowPosition(index, tasks.length)}
- *       onPress={() => open(task)}
- *     />
- *   ))}
- * </List>
- * ```
- */
-export declare const List: ({ children, style, testID }: ListProps) => ReactNode;
-export type ListRowProps = {
-    /** Primary line. A string renders with the row's own typography; a node is
-     *  rendered as given, for a title that needs its own styling. */
-    title?: ReactNode;
-    /** Second, dimmed line. Omitted rows are single-line, as `AdwActionRow`'s
-     *  are. */
-    subtitle?: ReactNode;
-    /** Leading content — a checkbox, an icon, a colour swatch. */
-    prefix?: ReactNode;
-    /** Trailing content — buttons, a value, a chevron. */
-    suffix?: ReactNode;
-    /** Makes the row activatable: it gains the hover and press tints and calls
-     *  this. Without it the row is inert, like a non-`activatable`
-     *  `AdwActionRow`. */
-    onPress?: () => void;
-    /** Position in the list, for the corner radii and the separator. Defaults
-     *  to `"middle"`, which is right for a row that is neither. */
-    position?: ListRowPosition;
-    /** Draw the hairline under this row. Default true for every position except
-     *  the last — set it false when the list supplies its own separators (a
-     *  `FlatList`'s `ItemSeparatorComponent`, say). */
-    separator?: boolean;
-    style?: StyleProp;
-    testID?: string;
-};
-/**
- * One row of a {@link List} — `AdwActionRow`'s layout and states, built from
- * `Pressable`, `View` and `Text`.
- *
- * Hover and press come from `Pressable`'s state callback, so they cost what
- * they cost anywhere else in this platform: the hover path swaps a CSS class
- * on the widget without a React render (see components/pressable.tsx).
- *
- * **Not yet:** keyboard navigation between rows and a focus ring.
- * `GtkListBox` implements those as widget behaviour and RN has no focus model
- * for `View` to hang them on — `Pressable`'s state is `{pressed, hovered}`
- * with no `focused`. The ring itself is now drawable (`outlineWidth` and
- * friends), so what is missing is the state, not the paint.
- */
-export declare const ListRow: ({ title, subtitle, prefix, suffix, onPress, position, separator, style, testID, }: ListRowProps) => ReactNode;
-/**
- * The hairline between two rows, for lists that draw their own separators —
- * a `FlatList`'s `ItemSeparatorComponent` is exactly this, and using it means
- * the rows themselves stay position-agnostic apart from their corners.
- */
-export declare const ListSeparator: () => ReactNode;