@vxrn/compiler 1.25.16 → 1.26.0

package/dist/cjs/worklets/autoworklet.cjs

@@ -0,0 +1,265 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var autoworklet_exports = {};
+__export(autoworklet_exports, {
+  AUTOWORKLET_FUNCTION_ARGS: () => AUTOWORKLET_FUNCTION_ARGS,
+  GESTURE_BUILDER_METHODS: () => GESTURE_BUILDER_METHODS,
+  WORKLET_DIRECTIVES: () => WORKLET_DIRECTIVES,
+  bodyStartAfterDirectives: () => bodyStartAfterDirectives,
+  findWorkletCandidates: () => findWorkletCandidates,
+  hasDirective: () => hasDirective,
+  hasWorkletDirective: () => hasWorkletDirective
+});
+module.exports = __toCommonJS(autoworklet_exports);
+const AUTOWORKLET_FUNCTION_ARGS = Object.assign(/* @__PURE__ */Object.create(null), {
+  useFrameCallback: [0],
+  useAnimatedStyle: [0],
+  useAnimatedProps: [0],
+  createAnimatedPropAdapter: [0],
+  useDerivedValue: [0],
+  useAnimatedScrollHandler: [0],
+  useAnimatedGestureHandler: [0],
+  useAnimatedReaction: [0, 1],
+  withTiming: [2],
+  withSpring: [2],
+  withDecay: [1],
+  withRepeat: [3],
+  runOnUI: [0],
+  executeOnUIRuntimeSync: [0],
+  scheduleOnUI: [0],
+  runOnUISync: [0],
+  runOnUIAsync: [0],
+  runOnRuntime: [1],
+  runOnRuntimeSync: [1],
+  runOnRuntimeAsync: [1],
+  scheduleOnRuntime: [1],
+  runOnRuntimeSyncWithId: [1],
+  scheduleOnRuntimeWithId: [1],
+  useTapGesture: [0],
+  usePanGesture: [0],
+  usePinchGesture: [0],
+  useRotationGesture: [0],
+  useFlingGesture: [0],
+  useLongPressGesture: [0],
+  useNativeGesture: [0],
+  useManualGesture: [0],
+  useHoverGesture: [0]
+});
+const GESTURE_BUILDER_METHODS = /* @__PURE__ */new Set(["onBegin", "onStart", "onEnd", "onFinalize", "onUpdate", "onChange", "onTouchesDown", "onTouchesMove", "onTouchesUp", "onTouchesCancelled"]);
+const GESTURE_KINDS = /* @__PURE__ */new Set(["Tap", "Pan", "Pinch", "Rotation", "Fling", "LongPress", "ForceTouch", "Native", "Manual", "Race", "Simultaneous", "Exclusive", "Hover"]);
+const LAYOUT_ANIMATIONS = new Set(`BounceIn BounceInDown BounceInLeft BounceInRight BounceInUp BounceOut BounceOutDown
+   BounceOutLeft BounceOutRight BounceOutUp FadeIn FadeInDown FadeInLeft FadeInRight FadeInUp
+   FadeOut FadeOutDown FadeOutLeft FadeOutRight FadeOutUp FlipInEasyX FlipInEasyY FlipInXDown
+   FlipInXUp FlipInYLeft FlipInYRight FlipOutEasyX FlipOutEasyY FlipOutXDown FlipOutXUp
+   FlipOutYLeft FlipOutYRight LightSpeedInLeft LightSpeedInRight LightSpeedOutLeft
+   LightSpeedOutRight PinwheelIn PinwheelOut RollInLeft RollInRight RollOutLeft RollOutRight
+   RotateInDownLeft RotateInDownRight RotateInUpLeft RotateInUpRight RotateOutDownLeft
+   RotateOutDownRight RotateOutUpLeft RotateOutUpRight SlideInDown SlideInLeft SlideInRight
+   SlideInUp SlideOutDown SlideOutLeft SlideOutRight SlideOutUp StretchInX StretchInY
+   StretchOutX StretchOutY ZoomIn ZoomInDown ZoomInEasyDown ZoomInEasyUp ZoomInLeft ZoomInRight
+   ZoomInRotate ZoomInUp ZoomOut ZoomOutDown ZoomOutEasyDown ZoomOutEasyUp ZoomOutLeft
+   ZoomOutRight ZoomOutRotate ZoomOutUp Layout LinearTransition SequencedTransition
+   FadingTransition JumpingTransition CurvedTransition EntryExitTransition`.split(/\s+/));
+const LAYOUT_ANIMATION_CHAIN_METHODS = /* @__PURE__ */new Set(["build", "duration", "delay", "getDuration", "randomDelay", "getDelay", "getDelayFunction", "easing", "rotate", "springify", "damping", "mass", "stiffness", "overshootClamping", "energyThreshold", "restDisplacementThreshold", "restSpeedThreshold", "withInitialValues", "getAnimationAndConfig", "easingX", "easingY", "easingWidth", "easingHeight", "entering", "exiting", "reverse"]);
+function isGestureObject(exp) {
+  return exp?.type === "CallExpression" && exp.callee?.type === "MemberExpression" && exp.callee.object?.type === "Identifier" && exp.callee.object.name === "Gesture" && exp.callee.property?.type === "Identifier" && GESTURE_KINDS.has(exp.callee.property.name);
+}
+function containsGestureObject(exp) {
+  if (isGestureObject(exp)) return true;
+  return exp?.type === "CallExpression" && exp.callee?.type === "MemberExpression" && containsGestureObject(exp.callee.object);
+}
+function isLayoutAnimationChain(exp) {
+  if (exp?.type === "Identifier" && LAYOUT_ANIMATIONS.has(exp.name)) return true;
+  if (exp?.type === "NewExpression" && exp.callee?.type === "Identifier" && LAYOUT_ANIMATIONS.has(exp.callee.name)) {
+    return true;
+  }
+  return exp?.type === "CallExpression" && exp.callee?.type === "MemberExpression" && exp.callee.property?.type === "Identifier" && LAYOUT_ANIMATION_CHAIN_METHODS.has(exp.callee.property.name) && isLayoutAnimationChain(exp.callee.object);
+}
+function isChainedCallback(callee) {
+  if (callee?.type !== "MemberExpression" || callee.property?.type !== "Identifier") {
+    return false;
+  }
+  const name = callee.property.name;
+  if (GESTURE_BUILDER_METHODS.has(name)) return containsGestureObject(callee.object);
+  if (name === "withCallback") return isLayoutAnimationChain(callee.object);
+  return false;
+}
+const WORKLET_DIRECTIVES = ["worklet", "no-worklet-closure", "limit-init-data-hoisting"];
+function statementDirective(stmt) {
+  if (!stmt || stmt.type !== "ExpressionStatement") return void 0;
+  if (typeof stmt.directive === "string") return stmt.directive;
+  if (stmt.expression?.type === "Literal" && typeof stmt.expression.value === "string") {
+    return stmt.expression.value;
+  }
+  return void 0;
+}
+function hasDirective(fnNode, directive) {
+  if (!fnNode || !fnNode.body) return false;
+  if (Array.isArray(fnNode.body.directives)) {
+    for (const d of fnNode.body.directives) {
+      if (d.directive === directive || d.value === directive) {
+        return true;
+      }
+    }
+  }
+  if (fnNode.body.type === "BlockStatement" && Array.isArray(fnNode.body.body)) {
+    for (const stmt of fnNode.body.body) {
+      const found = statementDirective(stmt);
+      if (found === void 0) break;
+      if (found === directive) return true;
+    }
+  }
+  return false;
+}
+function hasWorkletDirective(fnNode) {
+  return hasDirective(fnNode, "worklet");
+}
+function bodyStartAfterDirectives(fnNode, code) {
+  let start = fnNode.body.start + 1;
+  if (fnNode.body.type !== "BlockStatement" || !Array.isArray(fnNode.body.body)) return start;
+  for (const stmt of fnNode.body.body) {
+    const found = statementDirective(stmt);
+    if (found === void 0 || !WORKLET_DIRECTIVES.includes(found)) break;
+    start = stmt.end;
+    while (start < fnNode.body.end && (code[start] === ";" || /\s/.test(code[start]))) {
+      start++;
+    }
+  }
+  return start;
+}
+function findWorkletCandidates(program) {
+  const candidates = [];
+  const seenStarts = /* @__PURE__ */new Set();
+  function addCandidate(candidate) {
+    const fnStart = candidate.fnNode.start;
+    if (seenStarts.has(fnStart)) return;
+    seenStarts.add(fnStart);
+    candidates.push(candidate);
+  }
+  function getCalleeName(callee) {
+    if (!callee) return null;
+    if (callee.type === "Identifier") {
+      return callee.name;
+    }
+    if (callee.type === "MemberExpression" && !callee.computed && callee.property?.type === "Identifier") {
+      return callee.property.name;
+    }
+    return null;
+  }
+  function walk(node, parent) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      if (hasWorkletDirective(node)) {
+        let kind = "function_expression";
+        if (node.type === "FunctionDeclaration") kind = "function_declaration";else if (node.type === "ArrowFunctionExpression") kind = "arrow_function";
+        let name = node.id?.name;
+        if (!name && parent?.type === "VariableDeclarator" && parent.id?.name) {
+          name = parent.id.name;
+        }
+        addCandidate({
+          node,
+          fnNode: node,
+          kind,
+          name,
+          parent,
+          isAutoWorklet: false
+        });
+      }
+    } else if (node.type === "Property" && (node.method || node.value?.type === "FunctionExpression" || node.value?.type === "ArrowFunctionExpression")) {
+      const fn = node.value;
+      if (hasWorkletDirective(fn)) {
+        addCandidate({
+          node: node.method ? node : fn,
+          fnNode: fn,
+          kind: node.method ? "object_method" : fn.type === "ArrowFunctionExpression" ? "arrow_function" : "function_expression",
+          name: node.key?.name,
+          parent,
+          isAutoWorklet: false
+        });
+      }
+    }
+    if (node.type === "CallExpression") {
+      const calleeName = getCalleeName(node.callee);
+      const argIndices = calleeName ? AUTOWORKLET_FUNCTION_ARGS[calleeName] : void 0;
+      const chained = !argIndices && isChainedCallback(node.callee);
+      const indices = argIndices ?? (chained ? node.arguments.map((_, i) => i) : void 0);
+      if (indices) {
+        for (const idx of indices) {
+          const arg = node.arguments[idx];
+          if (!arg) continue;
+          if (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") {
+            let name = arg.id?.name;
+            if (!name && parent?.type === "VariableDeclarator" && parent.id?.name) {
+              name = parent.id.name;
+            }
+            addCandidate({
+              node: arg,
+              fnNode: arg,
+              kind: arg.type === "ArrowFunctionExpression" ? "arrow_function" : "function_expression",
+              name,
+              parent: node,
+              isAutoWorklet: true
+            });
+          } else if (arg.type === "ObjectExpression" && Array.isArray(arg.properties)) {
+            for (const prop of arg.properties) {
+              if (prop.type === "Property") {
+                if (prop.method) {
+                  addCandidate({
+                    node: prop,
+                    fnNode: prop.value,
+                    kind: "object_method",
+                    name: prop.key?.name,
+                    parent: arg,
+                    isAutoWorklet: true
+                  });
+                } else if (prop.value?.type === "ArrowFunctionExpression" || prop.value?.type === "FunctionExpression") {
+                  addCandidate({
+                    node: prop.value,
+                    fnNode: prop.value,
+                    kind: prop.value.type === "ArrowFunctionExpression" ? "arrow_function" : "function_expression",
+                    name: prop.key?.name,
+                    parent: prop,
+                    isAutoWorklet: true
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          walk(item, node);
+        }
+      } else if (child && typeof child === "object") {
+        walk(child, node);
+      }
+    }
+  }
+  walk(program, null);
+  return candidates;
+}

package/dist/cjs/worklets/globals.cjs

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var globals_exports = {};
+__export(globals_exports, {
+  DEFAULT_GLOBALS: () => DEFAULT_GLOBALS,
+  JS_GLOBALS: () => JS_GLOBALS,
+  createGlobalsSet: () => createGlobalsSet
+});
+module.exports = __toCommonJS(globals_exports);
+const JS_GLOBALS = /* @__PURE__ */new Set([
+// Value properties
+"globalThis", "Infinity", "NaN", "undefined",
+// Function properties
+"eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape",
+// Fundamental objects
+"Object", "Function", "Boolean", "Symbol",
+// Error objects
+"Error", "AggregateError", "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError", "InternalError",
+// Numbers and dates
+"Number", "BigInt", "Math", "Date",
+// Text processing
+"String", "RegExp",
+// Indexed collections
+"Array", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "BigInt64Array", "BigUint64Array", "Float32Array", "Float64Array",
+// Keyed collections
+"Map", "Set", "WeakMap", "WeakSet",
+// Structured data
+"ArrayBuffer", "SharedArrayBuffer", "DataView", "Atomics", "JSON",
+// Managing memory
+"WeakRef", "FinalizationRegistry",
+// Control abstraction objects
+"Iterator", "AsyncIterator", "Promise", "GeneratorFunction", "AsyncGeneratorFunction", "Generator", "AsyncGenerator", "AsyncFunction",
+// Reflection
+"Reflect", "Proxy",
+// Internationalization
+"Intl"]);
+const DEFAULT_GLOBALS = /* @__PURE__ */new Set([...JS_GLOBALS,
+// Environment / Runtime
+"null", "this", "global", "window", "self", "console", "performance", "arguments", "require", "fetch", "XMLHttpRequest", "WebSocket", "queueMicrotask", "requestAnimationFrame", "cancelAnimationFrame", "setTimeout", "clearTimeout", "setImmediate", "clearImmediate", "setInterval", "clearInterval", "HermesInternal", "_WORKLET"]);
+function createGlobalsSet(customGlobals, strictGlobal) {
+  const set = /* @__PURE__ */new Set();
+  if (!strictGlobal) {
+    for (const g of DEFAULT_GLOBALS) {
+      set.add(g);
+    }
+  }
+  if (customGlobals) {
+    for (const g of customGlobals) {
+      set.add(g);
+    }
+  }
+  return set;
+}

package/dist/cjs/worklets/hash.cjs

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var hash_exports = {};
+__export(hash_exports, {
+  calculateWorkletHash: () => calculateWorkletHash
+});
+module.exports = __toCommonJS(hash_exports);
+function calculateWorkletHash(str) {
+  let i = str.length;
+  let hash1 = 5381;
+  let hash2 = 52711;
+  while (i--) {
+    const char = str.charCodeAt(i);
+    hash1 = hash1 * 33 ^ char;
+    hash2 = hash2 * 33 ^ char;
+  }
+  return (hash1 >>> 0) * 4096 + (hash2 >>> 0);
+}