@depup/react-native-worklets 0.12.2-depup.0 → 0.13.0-depup.0

package/src/WorkletsModule/NativeWorklets.native.ts

@@ -183,10 +183,6 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
     );
   }
 
-  createSerializableInitializer(obj: object) {
-    return this.#workletsModuleProxy.createSerializableInitializer(obj);
-  }
-
   createSerializableNonWorkletFunction<TArgs extends unknown[], TReturn>(
     fun: (...args: TArgs) => TReturn,
     functionName: string | undefined
@@ -250,10 +246,12 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
 
   scheduleOnUI<TValue>(
     serializableArrayOfWorklets: SerializableRef<TValue[]>,
+    serializableArrayOfArguments: SerializableRef<unknown[]>,
     scheduleStacks: string[] | undefined
   ) {
     return this.#workletsModuleProxy.scheduleOnUI(
       serializableArrayOfWorklets,
+      serializableArrayOfArguments,
       scheduleStacks
     );
   }
@@ -271,7 +269,8 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
     useDefaultQueue: boolean,
     customQueue: object | undefined,
     enableEventLoop: boolean,
-    enableLocking: boolean
+    enableLocking: boolean,
+    enableNetworking: boolean
   ) {
     return this.#workletsModuleProxy.createWorkletRuntime(
       name,
@@ -279,7 +278,8 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
       useDefaultQueue,
       customQueue,
       enableEventLoop,
-      enableLocking
+      enableLocking,
+      enableNetworking
     );
   }
 
@@ -343,8 +343,11 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
     );
   }
 
-  createSynchronizable<TValue>(value: TValue): SynchronizableRef<TValue> {
-    return this.#workletsModuleProxy.createSynchronizable(value);
+  createSynchronizable<TValue>(
+    value: SerializableRef<TValue> | TValue,
+    isFixed: boolean
+  ): SynchronizableRef<TValue> {
+    return this.#workletsModuleProxy.createSynchronizable(value, isFixed);
   }
 
   synchronizableGetDirty<TValue>(
@@ -363,7 +366,7 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
 
   synchronizableSetBlocking<TValue>(
     synchronizableRef: SynchronizableRef<TValue>,
-    value: SerializableRef<TValue>
+    value: SerializableRef<TValue> | TValue
   ) {
     return this.#workletsModuleProxy.synchronizableSetBlocking(
       synchronizableRef,
@@ -371,6 +374,16 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
     );
   }
 
+  synchronizableSetDirty<TValue extends number | boolean>(
+    synchronizableRef: SynchronizableRef<TValue>,
+    value: TValue
+  ): void {
+    return this.#workletsModuleProxy.synchronizableSetDirty(
+      synchronizableRef,
+      value
+    );
+  }
+
   synchronizableLock<TValue>(
     synchronizableRef: SynchronizableRef<TValue>
   ): void {
@@ -395,6 +408,10 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
     this.#workletsModuleProxy.setDynamicFeatureFlag(name, value);
   }
 
+  getCurrentThreadId(): string {
+    return this.#workletsModuleProxy.getCurrentThreadId();
+  }
+
   getUIRuntimeHolder(): object {
     return this.#workletsModuleProxy.getUIRuntimeHolder();
   }

package/src/WorkletsModule/workletsModuleProxy.ts

@@ -108,8 +108,6 @@ export interface WorkletsModuleProxy {
     length: number
   ): SerializableRef<TValue>;
 
-  createSerializableInitializer(obj: object): SerializableRef<object>;
-
   createSerializableNonWorkletFunction<TArgs extends unknown[], TReturn>(
     fun: (...args: TArgs) => TReturn,
     functionName: string | undefined
@@ -147,6 +145,7 @@ export interface WorkletsModuleProxy {
 
   scheduleOnUI<TValue>(
     serializableArrayOfWorklets: SerializableRef<TValue[]>,
+    serializableArrayOfArguments: SerializableRef<unknown[]>,
     scheduleStacks: string[] | undefined
   ): void;
 
@@ -161,7 +160,8 @@ export interface WorkletsModuleProxy {
     useDefaultQueue: boolean,
     customQueue: object | undefined,
     enableEventLoop: boolean,
-    enableLocking: boolean
+    enableLocking: boolean,
+    enableNetworking: boolean
   ): WorkletRuntime;
 
   scheduleOnRuntime<TValue>(
@@ -197,7 +197,10 @@ export interface WorkletsModuleProxy {
 
   reportFatalErrorOnJS(message: string, stack: string, name: string): void;
 
-  createSynchronizable<TValue>(value: TValue): SynchronizableRef<TValue>;
+  createSynchronizable<TValue>(
+    value: SerializableRef<TValue> | TValue,
+    isFixed: boolean
+  ): SynchronizableRef<TValue>;
 
   synchronizableGetDirty<TValue>(
     synchronizableRef: SynchronizableRef<TValue>
@@ -209,7 +212,12 @@ export interface WorkletsModuleProxy {
 
   synchronizableSetBlocking<TValue>(
     synchronizableRef: SynchronizableRef<TValue>,
-    value: SerializableRef<TValue>
+    value: SerializableRef<TValue> | TValue
+  ): void;
+
+  synchronizableSetDirty<TValue extends number | boolean>(
+    synchronizableRef: SynchronizableRef<TValue>,
+    value: TValue
   ): void;
 
   synchronizableLock<TValue>(
@@ -224,6 +232,8 @@ export interface WorkletsModuleProxy {
 
   setDynamicFeatureFlag(name: string, value: boolean): void;
 
+  getCurrentThreadId(): string;
+
   getUIRuntimeHolder(): object;
 
   getUISchedulerHolder(): object;

package/src/debug/jsVersion.ts

@@ -5,4 +5,4 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '0.12.2';
+export const jsVersion = '0.13.0';

package/src/featureFlags/staticFlags.json

@@ -1,6 +1,5 @@
 {
   "RUNTIME_TEST_FLAG": false,
-  "FETCH_PREVIEW_ENABLED": false,
   "IOS_DYNAMIC_FRAMERATE_ENABLED": true,
   "ENABLE_CROSS_RUNTIME_STACK_TRACES": true
 }

package/src/featureFlags/types.ts

@@ -22,7 +22,6 @@ export type DynamicFlagName = keyof Omit<
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const DefaultStaticFeatureFlags = {
   RUNTIME_TEST_FLAG: false,
-  FETCH_PREVIEW_ENABLED: false,
   IOS_DYNAMIC_FRAMERATE_ENABLED: true,
   ENABLE_CROSS_RUNTIME_STACK_TRACES: true,
 } as const satisfies typeof StaticFeatureFlagsJSON;

package/src/index.ts

@@ -37,6 +37,7 @@ export { serializableMappingCache } from './memory/serializableMappingCache';
 export { createShareable } from './memory/shareable';
 export { createSynchronizable } from './memory/synchronizable';
 export type {
+  FixedSynchronizable,
   RegistrationData,
   SerializableRef,
   Shareable,
@@ -50,6 +51,7 @@ export type {
   ShareableHostMeta,
   ShareableHostProps,
   Synchronizable,
+  SynchronizableConfig,
   SynchronizableRef,
 } from './memory/types';
 export {
@@ -75,6 +77,7 @@ export {
 } from './runtimes';
 export {
   executeOnUIRuntimeSync,
+  getCurrentThreadId,
   runOnJS,
   runOnUI,
   runOnUIAsync,

package/src/initializers/initializers.native.ts

@@ -1,9 +1,7 @@
 'use strict';
 
 import { silenceHMRWarnings } from '../bundleMode/metroOverrides';
-import { initializeNetworking } from '../bundleMode/network';
 import { registerReportFatalRemoteError } from '../debug/errors';
-import { getStaticFeatureFlag } from '../featureFlags/featureFlags';
 import { bundleValueUnpacker } from '../memory/bundleUnpacker';
 import { installCustomSerializableUnpacker } from '../memory/customSerializableUnpacker';
 import { installRemoteFunctionUnpacker } from '../memory/remoteFunctionUnpacker';
@@ -12,12 +10,14 @@ import { installShareableGuestUnpacker } from '../memory/shareableGuestUnpacker'
 import { installShareableHostUnpacker } from '../memory/shareableHostUnpacker';
 import { installSynchronizableUnpacker } from '../memory/synchronizableUnpacker';
 import { installValueUnpacker } from '../memory/valueUnpacker';
+import { installNetworking } from '../networking/install';
+import { setupQueueMicrotask } from '../runLoop/common/queueMicrotaskPolyfill';
 import { setupSetImmediate } from '../runLoop/common/setImmediatePolyfill';
 import { setupSetInterval } from '../runLoop/common/setIntervalPolyfill';
 import { setupRequestAnimationFrame } from '../runLoop/uiRuntime/requestAnimationFrame';
 import { setupSetTimeout } from '../runLoop/uiRuntime/setTimeoutPolyfill';
 import { RuntimeKind } from '../runtimeKind';
-import { runOnUISync, scheduleOnRN, setupMicrotasks } from '../threads';
+import { runOnUISync, scheduleOnRN } from '../threads';
 import type { ValueUnpacker } from '../types';
 import { isWorkletFunction } from '../workletFunction';
 import { WorkletsModule } from '../WorkletsModule/NativeWorklets';
@@ -172,9 +172,7 @@ function initializeWorkletRuntime() {
       silenceHMRWarnings();
     }
 
-    if (getStaticFeatureFlag('FETCH_PREVIEW_ENABLED')) {
-      initializeNetworking();
-    }
+    installNetworking();
   }
 }
 
@@ -196,19 +194,13 @@ function installRNBindingsOnUIRuntime() {
 
   runOnUISync(() => {
     'worklet';
-    /**
-     * TODO: Move `setupMicrotasks` and `setupRequestAnimationFrame` to a
-     * separate function once we have a better way to distinguish between
-     * Worklet Runtimes.
-     */
-
     if (!globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
       setupConsole(runtimeBoundCapturableConsole!);
     } else if (__DEV__) {
       setupConsoleForwarding(runtimeBoundCapturableConsole!);
     }
 
-    setupMicrotasks();
+    setupQueueMicrotask();
     setupRequestAnimationFrame();
     setupSetTimeout();
     setupSetImmediate();

package/src/memory/bundleUnpacker.native.ts

@@ -3,19 +3,10 @@
 import { logger } from '../debug/logger';
 import type { WorkletFactory, WorkletFunction } from '../types';
 
-const handleCache = new WeakMap<WorkletFunction, unknown>();
-
 export function bundleValueUnpacker(objectToUnpack: ObjectToUnpack): unknown {
   const workletHash = objectToUnpack.__workletHash;
   if (workletHash !== undefined) {
     return getWorklet(workletHash, objectToUnpack.__closure);
-  } else if (objectToUnpack.__init !== undefined) {
-    let value = handleCache.get(objectToUnpack);
-    if (value === undefined) {
-      value = objectToUnpack.__init();
-      handleCache.set(objectToUnpack, value);
-    }
-    return value;
   } else {
     throw new Error(
       `[Worklets] Data type not recognized by value unpacker: "${globalThis._toString(
@@ -27,7 +18,7 @@ export function bundleValueUnpacker(objectToUnpack: ObjectToUnpack): unknown {
 
 function getWorklet(
   workletHash: number,
-  closureVariables: Record<string, unknown>
+  closureVariables: unknown[] | undefined
 ): WorkletFunction | undefined {
   let worklet;
   if (__DEV__) {
@@ -48,10 +39,12 @@ const metroRequire = globalThis.__r;
 
 function getWorkletFromMetroRequire(
   workletHash: number,
-  closureVariables: Record<string, unknown>
+  closureVariables: unknown[] | undefined
 ): WorkletFunction {
-  const factory = metroRequire(workletHash).default as WorkletFactory;
-  return factory(closureVariables);
+  const exportedWorklet = metroRequire(workletHash).default;
+  return closureVariables === undefined
+    ? (exportedWorklet as WorkletFunction)
+    : (exportedWorklet as WorkletFactory)(closureVariables);
 }
 
 interface ObjectToUnpack extends WorkletFunction {

package/src/memory/serializable.native.ts

@@ -181,16 +181,6 @@ export function createSerializable<TValue>(
   if (isHostObject(value)) {
     return cloneHostObject(value);
   }
-  if (isPlainJSObject(value) && value.__init) {
-    return cloneInitializer(
-      value,
-      shouldPersistRemote,
-      depth
-    ) as SerializableRef<TValue>;
-  }
-  if (isPlainJSObject(value) && value.__workletContextObjectFactory) {
-    return cloneContextObject(value);
-  }
   if ((isPlainJSObject(value) || isFunction) && isWorkletFunction(value)) {
     return cloneWorklet(value, shouldPersistRemote, depth);
   }
@@ -397,19 +387,6 @@ function cloneObjectProperties<T extends object>(
   return clonedProps;
 }
 
-function cloneInitializer(
-  value: object,
-  shouldPersistRemote = false,
-  depth = 0
-): SerializableRef<object> {
-  const clonedProps: Record<string, unknown> = cloneObjectProperties(
-    value,
-    shouldPersistRemote,
-    depth
-  );
-  return WorkletsModule.createSerializableInitializer(clonedProps);
-}
-
 function cloneArray<T extends unknown[]>(
   value: T,
   shouldPersistRemote: boolean,
@@ -541,21 +518,6 @@ function cloneTurboModuleLike<TValue extends object>(
   return clone;
 }
 
-function cloneContextObject<TValue extends object>(
-  value: TValue
-): SerializableRef<TValue> {
-  const workletContextObjectFactory = (value as Record<string, unknown>)
-    .__workletContextObjectFactory as () => TValue;
-  const handle = cloneInitializer({
-    __init: () => {
-      'worklet';
-      return workletContextObjectFactory();
-    },
-  });
-  serializableMappingCache.set(value, handle);
-  return handle as SerializableRef<TValue>;
-}
-
 function clonePlainJSObject<TValue extends object>(
   value: TValue,
   shouldPersistRemote: boolean,
@@ -948,12 +910,7 @@ export function makeShareable<TValue extends object>(value: TValue): TValue {
   if (serializableMappingCache.get(value)) {
     return value;
   }
-  const handle = createSerializable({
-    __init: () => {
-      'worklet';
-      return value;
-    },
-  });
+  const handle = createSerializable(value, true);
   serializableMappingCache.set(value, handle);
   return value;
 }

package/src/memory/synchronizable.native.ts

@@ -2,16 +2,50 @@
 
 import { WorkletsModule } from '../WorkletsModule/NativeWorklets';
 import { createSerializable } from './serializable';
-import type { Synchronizable } from './types';
+import type {
+  FixedSynchronizable,
+  Synchronizable,
+  SynchronizableConfig,
+} from './types';
+
+export function createSynchronizable<TValue extends number | boolean>(
+  initialValue: TValue,
+  config: SynchronizableConfig & { fixedType: true }
+): FixedSynchronizable<TValue extends boolean ? boolean : number>;
+
+export function createSynchronizable<TValue extends number | boolean>(
+  initialValue: TValue,
+  config: SynchronizableConfig
+): Synchronizable<TValue> | FixedSynchronizable<TValue>;
+
+export function createSynchronizable<TValue = unknown>(
+  initialValue: TValue,
+  config?: SynchronizableConfig
+): Synchronizable<TValue>;
 
 export function createSynchronizable<TValue = unknown>(
-  initialValue: TValue
+  initialValue: TValue,
+  config?: SynchronizableConfig
 ): Synchronizable<TValue> {
+  const isFixed = !!config?.fixedType;
+
+  if (
+    __DEV__ &&
+    isFixed &&
+    !(typeof initialValue === 'number' || typeof initialValue === 'boolean')
+  ) {
+    throw new Error(
+      '[Worklets] `fixedType` requires a number or boolean initial value.'
+    );
+  }
+
   const synchronizableRef = WorkletsModule.createSynchronizable(
-    createSerializable(initialValue)
+    isFixed ? initialValue : createSerializable(initialValue),
+    isFixed
   );
 
   return globalThis.__synchronizableUnpacker(
-    synchronizableRef
+    synchronizableRef,
+    isFixed
   ) as unknown as Synchronizable<TValue>;
 }

package/src/memory/synchronizable.ts

@@ -1,9 +1,29 @@
 'use strict';
 
-import type { Synchronizable } from './types';
+import type {
+  FixedSynchronizable,
+  Synchronizable,
+  SynchronizableConfig,
+} from './types';
+
+export function createSynchronizable<TValue extends number | boolean>(
+  initialValue: TValue,
+  config: SynchronizableConfig & { fixedType: true }
+): FixedSynchronizable<TValue extends boolean ? boolean : number>;
+
+export function createSynchronizable<TValue extends number | boolean>(
+  initialValue: TValue,
+  config: SynchronizableConfig
+): Synchronizable<TValue> | FixedSynchronizable<TValue>;
+
+export function createSynchronizable<TValue = unknown>(
+  initialValue: TValue,
+  config?: SynchronizableConfig
+): Synchronizable<TValue>;
 
 export function createSynchronizable<TValue = unknown>(
-  _value: TValue
+  _initialValue: TValue,
+  _config?: SynchronizableConfig
 ): Synchronizable<TValue> {
   throw new Error('[Worklets] `createSynchronizable` is not supported on web.');
 }

package/src/memory/synchronizableUnpacker.native.ts

@@ -3,7 +3,11 @@
 /* eslint-disable @typescript-eslint/no-require-imports */
 'use strict';
 
-import { type Synchronizable, type SynchronizableRef } from './types';
+import {
+  type FixedSynchronizable,
+  type Synchronizable,
+  type SynchronizableRef,
+} from './types';
 
 export function installSynchronizableUnpacker() {
   'worklet';
@@ -15,7 +19,8 @@ export function installSynchronizableUnpacker() {
       : (value: unknown) => globalThis.__serializer(value);
 
   function synchronizableUnpacker<TValue>(
-    synchronizableRef: SynchronizableRef<TValue>
+    synchronizableRef: SynchronizableRef<TValue>,
+    isFixed: boolean
   ): Synchronizable<TValue> {
     const synchronizable =
       synchronizableRef as unknown as Synchronizable<TValue>;
@@ -29,7 +34,10 @@ export function installSynchronizableUnpacker() {
       return proxy.synchronizableGetBlocking(synchronizable);
     };
     const setBlockingValue = (newValue: TValue) => {
-      proxy.synchronizableSetBlocking(synchronizable, serializer(newValue));
+      proxy.synchronizableSetBlocking(
+        synchronizable,
+        isFixed ? newValue : serializer(newValue)
+      );
     };
     synchronizable.setBlocking = (
       valueOrFunction: TValue | ((prev: TValue) => TValue)
@@ -59,6 +67,16 @@ export function installSynchronizableUnpacker() {
     synchronizable.unlock = () => {
       proxy.synchronizableUnlock(synchronizable);
     };
+    if (isFixed) {
+      (
+        synchronizable as unknown as FixedSynchronizable<number | boolean>
+      ).setDirty = (value: number | boolean) => {
+        proxy.synchronizableSetDirty(
+          synchronizable as unknown as SynchronizableRef<number | boolean>,
+          value
+        );
+      };
+    }
 
     return synchronizable;
   }
@@ -67,5 +85,6 @@ export function installSynchronizableUnpacker() {
 }
 
 export type SynchronizableUnpacker = <TValue>(
-  synchronizableRef: SynchronizableRef<TValue>
+  synchronizableRef: SynchronizableRef<TValue>,
+  isFixed: boolean
 ) => Synchronizable<TValue>;

package/src/memory/types.ts

@@ -36,6 +36,15 @@ export type Synchronizable<TValue = unknown> = SerializableRef<TValue> &
     unlock(): void;
   };
 
+export type FixedSynchronizable<TValue extends number | boolean> =
+  Synchronizable<TValue> & {
+    setDirty(value: TValue): void;
+  };
+
+export type SynchronizableConfig = {
+  fixedType?: boolean;
+};
+
 /**
  * Registration data for
  * [registerCustomSerializable](https://docs.swmansion.com/react-native-worklets/docs/memory/registerCustomSerializable)

package/src/memory/valueUnpacker.native.ts

@@ -16,7 +16,6 @@ export function installValueUnpacker() {
   'worklet';
   'no-worklet-closure';
   const workletsCache = new Map<number, () => unknown>();
-  const handleCache = new WeakMap<object, unknown>();
 
   function valueUnpacker(objectToUnpack: ObjectToUnpack): unknown {
     const workletHash = objectToUnpack.__workletHash;
@@ -55,13 +54,6 @@ export function installValueUnpacker() {
       const functionInstance = workletFun!.bind(objectToUnpack);
       objectToUnpack._recur = functionInstance;
       return functionInstance;
-    } else if (objectToUnpack.__init !== undefined) {
-      let value = handleCache.get(objectToUnpack);
-      if (value === undefined) {
-        value = objectToUnpack.__init();
-        handleCache.set(objectToUnpack, value);
-      }
-      return value;
     } else {
       throw new Error(
         `[Worklets] Data type not recognized by value unpacker: "${globalThis._toString(

package/src/mock.ts

@@ -44,9 +44,36 @@ const WorkletAPI = {
       setSync: set,
     };
   },
-  createSynchronizable: ID,
+  createSynchronizable: <TValue>(
+    initialValue: TValue,
+    config?: { fixedType?: boolean }
+  ) => {
+    let value = initialValue;
+    const synchronizable = {
+      __synchronizableRef: true,
+      getDirty: () => value,
+      getBlocking: () => value,
+      setBlocking: (newValue: TValue | ((prev: TValue) => TValue)) => {
+        value =
+          typeof newValue === 'function'
+            ? (newValue as (prev: TValue) => TValue)(value)
+            : newValue;
+      },
+      lock: NOOP,
+      unlock: NOOP,
+    };
+    if (config?.fixedType) {
+      Object.assign(synchronizable, {
+        setDirty: (newValue: TValue) => {
+          value = newValue;
+        },
+      });
+    }
+    return synchronizable;
+  },
   createWorkletRuntime: NOOP_FACTORY,
   executeOnUIRuntimeSync: ID,
+  getCurrentThreadId: () => '0',
   getDynamicFeatureFlag: () => false,
   getRuntimeKind: () => RuntimeKind.ReactNative,
   getStaticFeatureFlag: () => false,

package/src/networking/AbortController.ts

@@ -0,0 +1,57 @@
+'use strict';
+
+import type { NetworkingEventListener } from './events';
+import { EventTargetLite } from './events';
+
+export class AbortSignal extends EventTargetLite {
+  aborted = false;
+  reason: unknown = undefined;
+  onabort: NetworkingEventListener | null = null;
+
+  static abort(reason?: unknown): AbortSignal {
+    const signal = new AbortSignal();
+    signal.__abort(reason);
+    return signal;
+  }
+
+  static timeout(delayMs: number): AbortSignal {
+    const signal = new AbortSignal();
+    setTimeout(() => signal.__abort(makeAbortError('TimeoutError')), delayMs);
+    return signal;
+  }
+
+  throwIfAborted() {
+    if (this.aborted) {
+      throw this.reason;
+    }
+  }
+
+  __abort(reason?: unknown) {
+    if (this.aborted) {
+      return;
+    }
+    this.aborted = true;
+    this.reason = reason !== undefined ? reason : makeAbortError('AbortError');
+    this.__dispatch('abort');
+  }
+}
+
+export class AbortController {
+  readonly signal = new AbortSignal();
+
+  abort(reason?: unknown) {
+    this.signal.__abort(reason);
+  }
+}
+
+function makeAbortError(name: string): Error {
+  const error = new Error(
+    `[Worklets] ${
+      name === 'TimeoutError'
+        ? 'The operation timed out.'
+        : 'The operation was aborted.'
+    }`
+  );
+  error.name = name;
+  return error;
+}