@amazon-devices/react-native-worklets 1.0.0 → 1.0.2

package/src/valueUnpacker.ts

@@ -1,90 +0,0 @@
-'use strict';
-import type { ValueUnpacker, WorkletFunction } from './workletTypes';
-
-declare global {
-  var evalWithSourceMap:
-    | ((js: string, sourceURL: string, sourceMap: string) => () => unknown)
-    | undefined;
-  var evalWithSourceUrl:
-    | ((js: string, sourceURL: string) => () => unknown)
-    | undefined;
-}
-
-function __installUnpacker() {
-  const workletsCache = new Map<number, () => unknown>();
-  const handleCache = new WeakMap<object, unknown>();
-
-  function valueUnpacker(
-    objectToUnpack: ObjectToUnpack,
-    category?: string,
-    remoteFunctionName?: string
-  ): unknown {
-    'use strict';
-    const workletHash = objectToUnpack.__workletHash;
-    if (workletHash !== undefined) {
-      let workletFun = workletsCache.get(workletHash);
-      if (workletFun === undefined) {
-        const initData = objectToUnpack.__initData;
-        if (globalThis.evalWithSourceMap) {
-          // if the runtime (hermes only for now) supports loading source maps
-          // we want to use the proper filename for the location as it guarantees
-          // that debugger understands and loads the source code of the file where
-          // the worklet is defined.
-          workletFun = globalThis.evalWithSourceMap(
-            '(' + initData!.code + '\n)',
-            initData!.location!,
-            initData!.sourceMap!
-          );
-        } else if (globalThis.evalWithSourceUrl) {
-          // if the runtime doesn't support loading source maps, in dev mode we
-          // can pass source url when evaluating the worklet. Now, instead of using
-          // the actual file location we use worklet hash, as it the allows us to
-          // properly symbolicate traces (see errors.ts for details)
-          workletFun = globalThis.evalWithSourceUrl(
-            '(' + initData!.code + '\n)',
-            `worklet_${workletHash}`
-          );
-        } else {
-          // in release we use the regular eval to save on JSI calls
-          // eslint-disable-next-line no-eval
-          workletFun = eval('(' + initData!.code + '\n)');
-        }
-        workletsCache.set(workletHash, workletFun!);
-      }
-      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 if (category === 'RemoteFunction') {
-      const fun = () => {
-        const label = remoteFunctionName
-          ? `function \`${remoteFunctionName}\``
-          : 'anonymous function';
-        // eslint-disable-next-line reanimated/use-worklets-error
-        throw new Error(`[Worklets] Tried to synchronously call a non-worklet ${label} on the UI thread.
-See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-synchronously-call-a-non-worklet-function-on-the-ui-thread for more details.`);
-      };
-      fun.__remoteFunction = objectToUnpack;
-      return fun;
-    } else {
-      // eslint-disable-next-line reanimated/use-worklets-error
-      throw new Error(
-        `[Worklets] Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(
-          objectToUnpack
-        )}".`
-      );
-    }
-  }
-
-  globalThis.__valueUnpacker = valueUnpacker as ValueUnpacker;
-}
-
-interface ObjectToUnpack extends WorkletFunction {
-  _recur: unknown;
-}

package/src/workletFunction.ts

@@ -1,42 +0,0 @@
-'use strict';
-
-import type { WorkletFunction } from './workletTypes';
-
-/**
- * This function allows you to determine if a given function is a worklet. It
- * only works with Reanimated Babel plugin enabled. Unless you are doing
- * something with internals of Reanimated you shouldn't need to use this
- * function.
- *
- * ### Note
- *
- * Do not call it before the worklet is declared, as it will always return false
- * then. E.g.:
- *
- * ```ts
- * isWorkletFunction(myWorklet); // Will always return false.
- *
- * function myWorklet() {
- *   'worklet';
- * }
- * ```
- *
- * ### Maintainer note
- *
- * This function is supposed to be used only in the React Runtime. It always
- * returns `false` in Worklet Runtimes.
- */
-export function isWorkletFunction<
-  Args extends unknown[] = unknown[],
-  ReturnValue = unknown,
->(value: unknown): value is WorkletFunction<Args, ReturnValue> {
-  'worklet';
-  // Since host objects always return true for `in` operator, we have to use dot notation to check if the property exists.
-  // See https://github.com/facebook/hermes/blob/340726ef8cf666a7cce75bc60b02fa56b3e54560/lib/VM/JSObject.cpp#L1276.
-
-  return (
-    // `__workletHash` isn't extracted in Worklet Runtimes.
-    typeof value === 'function' &&
-    !!(value as unknown as Record<string, unknown>).__workletHash
-  );
-}

package/src/workletRuntimeEntry.ts

@@ -1,35 +0,0 @@
-'use strict';
-
-import { init } from './initializers';
-import { SHOULD_BE_USE_WEB } from './PlatformChecker';
-import { RuntimeKind } from './runtimeKind';
-import { WorkletsError } from './WorkletsError';
-
-/**
- * This function is an entry point for Worklet Runtimes. We can use it to setup
- * necessary tools, like the ValueUnpacker.
- *
- * We must throw an error at the end of this function to prevent the bundle to
- * continue executing. This is because the next module to be ran would be the
- * React Native one, and it would break the Worklet Runtime if initialized. The
- * error is caught in C++ code.
- *
- * This function has no effect on the RN Runtime beside setting the
- * `_WORKLETS_BUNDLE_MODE` flag.
- */
-export function bundleModeInit() {
-  globalThis._WORKLETS_BUNDLE_MODE = true;
-  if (
-    !SHOULD_BE_USE_WEB &&
-    globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative
-  ) {
-    /**
-     * We shouldn't call `init()` on RN Runtime here, as it would initialize our
-     * module before React Native has configured the RN Runtime.
-     */
-    init();
-    throw new WorkletsError('Worklets initialized successfully');
-  }
-}
-
-bundleModeInit();

package/src/workletTypes.ts

@@ -1,81 +0,0 @@
-'use strict';
-
-/**
- * The below type is used for HostObjects returned by the JSI API that don't
- * have any accessible fields or methods but can carry data that is accessed
- * from the c++ side. We add a field to the type to make it possible for
- * typescript to recognize which JSI methods accept those types as arguments and
- * to be able to correctly type check other methods that may use them. However,
- * this field is not actually defined nor should be used for anything else as
- * assigning any data to those objects will throw an error.
- */
-export type SerializableRef<T = unknown> = {
-  __serializableRef: true;
-  __nativeStateSerializableJSRef: T;
-};
-
-// In case of objects with depth or arrays of objects or arrays of arrays etc.
-// we add this utility type that makes it a `SharaebleRef` of the outermost type.
-export type FlatSerializableRef<T> =
-  T extends SerializableRef<infer U> ? SerializableRef<U> : SerializableRef<T>;
-
-export type WorkletRuntime = {
-  __hostObjectWorkletRuntime: never;
-  readonly name: string;
-};
-
-export type WorkletStackDetails = [
-  error: Error,
-  lineOffset: number,
-  columnOffset: number,
-];
-
-export type WorkletClosure = Record<string, unknown>;
-
-interface WorkletInitData {
-  code: string;
-  /** Only in dev builds. */
-  location?: string;
-  /** Only in dev builds. */
-  sourceMap?: string;
-}
-
-interface WorkletProps {
-  __closure: WorkletClosure;
-  __workletHash: number;
-  /** Only in Legacy Bundling. */
-  __initData?: WorkletInitData;
-  /** Only for Handles. */
-  __init?: () => unknown;
-  /** `__stackDetails` is removed after parsing. */
-  __stackDetails?: WorkletStackDetails;
-  /** Only in dev builds. */
-  __pluginVersion?: string;
-}
-
-export type WorkletFunction<
-  TArgs extends unknown[] = unknown[],
-  TReturn = unknown,
-> = ((...args: TArgs) => TReturn) & WorkletProps;
-
-export interface WorkletFactory<
-  TArgs extends unknown[] = unknown[],
-  TReturn = unknown,
-  TClosureVariables extends Record<string, unknown> = Record<string, unknown>,
-> {
-  (closureVariables: TClosureVariables): WorkletFunction<TArgs, TReturn>;
-}
-
-export type ValueUnpacker = WorkletFunction<
-  [objectToUnpack: unknown, category?: string],
-  unknown
->;
-
-export interface WorkletImport {
-  __bundleData: {
-    /** Name of the module which is the source of the import. */
-    source: string;
-    /** The name of the imported value. */
-    imported: string;
-  };
-}