@vxrn/compiler 1.25.16 → 1.26.0

package/dist/cjs/worklets/scope.cjs

@@ -0,0 +1,370 @@
+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 scope_exports = {};
+__export(scope_exports, {
+  getClosureVariables: () => getClosureVariables
+});
+module.exports = __toCommonJS(scope_exports);
+function getClosureVariables(fnNode, globals) {
+  const rootScope = {
+    parent: null,
+    isFunction: true,
+    bindings: /* @__PURE__ */new Set(),
+    varBindings: /* @__PURE__ */new Set()
+  };
+  let currentScope = rootScope;
+  const freeVariables = /* @__PURE__ */new Set();
+  if (fnNode.id && fnNode.id.name) {
+    rootScope.bindings.add(fnNode.id.name);
+  }
+  function pushScope(isFunction) {
+    const newScope = {
+      parent: currentScope,
+      isFunction,
+      bindings: /* @__PURE__ */new Set(),
+      varBindings: isFunction ? /* @__PURE__ */new Set() : currentScope.varBindings
+    };
+    currentScope = newScope;
+    return newScope;
+  }
+  function popScope() {
+    if (currentScope.parent) {
+      currentScope = currentScope.parent;
+    }
+  }
+  function addBindings(pattern, targetSet) {
+    if (!pattern) return;
+    switch (pattern.type) {
+      case "Identifier":
+        targetSet.add(pattern.name);
+        break;
+      case "AssignmentPattern":
+        addBindings(pattern.left, targetSet);
+        walk(pattern.right);
+        break;
+      case "RestElement":
+        addBindings(pattern.argument, targetSet);
+        break;
+      case "ArrayPattern":
+        for (const el of pattern.elements) {
+          if (el) addBindings(el, targetSet);
+        }
+        break;
+      case "ObjectPattern":
+        for (const prop of pattern.properties) {
+          if (prop.type === "Property") {
+            if (prop.computed) walk(prop.key);
+            addBindings(prop.value, targetSet);
+          } else if (prop.type === "RestElement") {
+            addBindings(prop.argument, targetSet);
+          }
+        }
+        break;
+    }
+  }
+  function addBindingsOnly(pattern, targetSet) {
+    if (!pattern) return;
+    switch (pattern.type) {
+      case "Identifier":
+        targetSet.add(pattern.name);
+        break;
+      case "AssignmentPattern":
+        addBindingsOnly(pattern.left, targetSet);
+        break;
+      case "RestElement":
+        addBindingsOnly(pattern.argument, targetSet);
+        break;
+      case "ArrayPattern":
+        for (const el of pattern.elements) {
+          if (el) addBindingsOnly(el, targetSet);
+        }
+        break;
+      case "ObjectPattern":
+        for (const prop of pattern.properties) {
+          if (prop.type === "Property") {
+            addBindingsOnly(prop.value, targetSet);
+          } else if (prop.type === "RestElement") {
+            addBindingsOnly(prop.argument, targetSet);
+          }
+        }
+        break;
+    }
+  }
+  function hoistDeclarations(node, direct) {
+    if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+    switch (node.type) {
+      case "FunctionDeclaration":
+        if (node.id?.name) {
+          currentScope.bindings.add(node.id.name);
+          currentScope.varBindings.add(node.id.name);
+        }
+        return;
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return;
+      case "ClassDeclaration":
+        if (direct && node.id?.name) currentScope.bindings.add(node.id.name);
+        return;
+      case "VariableDeclaration":
+        if (node.kind === "var") {
+          for (const d of node.declarations) addBindingsOnly(d.id, currentScope.varBindings);
+        } else if (direct) {
+          for (const d of node.declarations) addBindingsOnly(d.id, currentScope.bindings);
+        }
+        return;
+      case "ExportNamedDeclaration":
+      case "ExportDefaultDeclaration":
+        hoistDeclarations(node.declaration, direct);
+        return;
+    }
+    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) hoistDeclarations(item, false);
+      } else if (child && typeof child === "object") {
+        hoistDeclarations(child, false);
+      }
+    }
+  }
+  if (fnNode.params) {
+    for (const param of fnNode.params) {
+      addBindings(param, rootScope.bindings);
+    }
+  }
+  function isDeclaredInScopes(name, fromScope) {
+    let s = fromScope;
+    while (s) {
+      if (s.bindings.has(name) || s.varBindings.has(name)) {
+        return true;
+      }
+      s = s.parent;
+    }
+    return false;
+  }
+  function resolveIdentifier(name) {
+    if (!isDeclaredInScopes(name, currentScope) && !globals.has(name)) {
+      freeVariables.add(name);
+    }
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "TSTypeAnnotation" || node.type === "TSTypeReference" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeParameterDeclaration" || node.type === "TSTypeParameterInstantiation" || node.type === "TSTypeQuery" || node.type === "TSQualifiedName") {
+      return;
+    }
+    if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSInstantiationExpression") {
+      walk(node.expression);
+      return;
+    }
+    switch (node.type) {
+      case "BlockStatement":
+        {
+          const isRootBody = node === fnNode.body;
+          if (!isRootBody) {
+            pushScope(false);
+          }
+          for (const stmt of node.body) {
+            hoistDeclarations(stmt, true);
+          }
+          for (const stmt of node.body) {
+            walk(stmt);
+          }
+          if (!isRootBody) {
+            popScope();
+          }
+          return;
+        }
+      case "VariableDeclaration":
+        {
+          const isVar = node.kind === "var";
+          const targetSet = isVar ? currentScope.varBindings : currentScope.bindings;
+          for (const decl of node.declarations) {
+            addBindings(decl.id, targetSet);
+            if (decl.init) walk(decl.init);
+          }
+          return;
+        }
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+        {
+          if (node.id && node.id.name) {
+            currentScope.bindings.add(node.id.name);
+          }
+          pushScope(true);
+          if (node.params) {
+            for (const param of node.params) {
+              addBindings(param, currentScope.bindings);
+            }
+          }
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ArrowFunctionExpression":
+        {
+          pushScope(true);
+          if (node.params) {
+            for (const param of node.params) {
+              addBindings(param, currentScope.bindings);
+            }
+          }
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "CatchClause":
+        {
+          pushScope(false);
+          if (node.param) {
+            addBindings(node.param, currentScope.bindings);
+          }
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ForStatement":
+        {
+          pushScope(false);
+          if (node.init) walk(node.init);
+          if (node.test) walk(node.test);
+          if (node.update) walk(node.update);
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ForInStatement":
+      case "ForOfStatement":
+        {
+          pushScope(false);
+          walk(node.left);
+          walk(node.right);
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ClassDeclaration":
+      case "ClassExpression":
+        {
+          if (node.id && node.id.name) {
+            currentScope.bindings.add(node.id.name);
+          }
+          if (node.superClass) walk(node.superClass);
+          pushScope(false);
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "MemberExpression":
+        {
+          walk(node.object);
+          if (node.computed) {
+            walk(node.property);
+          }
+          return;
+        }
+      case "Property":
+        {
+          if (node.computed) {
+            walk(node.key);
+          }
+          walk(node.value);
+          return;
+        }
+      case "MethodDefinition":
+        {
+          if (node.computed) {
+            walk(node.key);
+          }
+          walk(node.value);
+          return;
+        }
+      case "Identifier":
+        {
+          resolveIdentifier(node.name);
+          return;
+        }
+      case "JSXElement":
+        {
+          if (node.openingElement) {
+            const nameNode = node.openingElement.name;
+            if (nameNode.type === "JSXIdentifier") {
+              if (/^[A-Z]/.test(nameNode.name)) {
+                resolveIdentifier(nameNode.name);
+              }
+            } else if (nameNode.type === "JSXMemberExpression") {
+              let root = nameNode.object;
+              while (root.type === "JSXMemberExpression") {
+                root = root.object;
+              }
+              if (root.type === "JSXIdentifier") {
+                resolveIdentifier(root.name);
+              }
+            }
+            if (node.openingElement.attributes) {
+              for (const attr of node.openingElement.attributes) {
+                walk(attr);
+              }
+            }
+          }
+          if (node.children) {
+            for (const child of node.children) {
+              walk(child);
+            }
+          }
+          return;
+        }
+      case "JSXAttribute":
+        {
+          if (node.value) {
+            walk(node.value);
+          }
+          return;
+        }
+      case "JSXExpressionContainer":
+        {
+          walk(node.expression);
+          return;
+        }
+      case "BreakStatement":
+      case "ContinueStatement":
+      case "LabeledStatement":
+        {
+          if (node.body) walk(node.body);
+          return;
+        }
+    }
+    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);
+        }
+      } else if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+  }
+  walk(fnNode.body);
+  return Array.from(freeVariables).sort();
+}

package/dist/cjs/worklets/serialize.cjs

@@ -0,0 +1,101 @@
+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 serialize_exports = {};
+__export(serialize_exports, {
+  buildLocalFunction: () => buildLocalFunction,
+  serializeWorkletForUI: () => serializeWorkletForUI
+});
+module.exports = __toCommonJS(serialize_exports);
+var import_oxc_transform = require("oxc-transform");
+var import_autoworklet = require("./autoworklet.cjs");
+function assertTransformed(transformed, name, what) {
+  const error = transformed.errors?.[0];
+  if (error) {
+    throw new Error(`[worklets] failed to build ${what} code for ${name || "anonymous worklet"}: ${error.message || error}`);
+  }
+  if (!transformed.code.trim()) {
+    throw new Error(`[worklets] built empty ${what} code for ${name || "anonymous worklet"}`);
+  }
+}
+function serializeWorkletForUI(fnNode, code, name, closureVars) {
+  let rawParams = "";
+  if (fnNode.params && fnNode.params.length > 0) {
+    const pStart = fnNode.params[0].start;
+    const pEnd = fnNode.params[fnNode.params.length - 1].end;
+    rawParams = code.slice(pStart, pEnd);
+  }
+  let rawBody = "";
+  if (fnNode.body.type === "BlockStatement") {
+    const bodyStart = (0, import_autoworklet.bodyStartAfterDirectives)(fnNode, code);
+    const bodyEnd = fnNode.body.end - 1;
+    rawBody = code.slice(bodyStart, bodyEnd);
+  } else {
+    rawBody = `return ${code.slice(fnNode.body.start, fnNode.body.end)};`;
+  }
+  const unpacker = closureVars.length > 0 ? `const { ${closureVars.join(", ")} } = this.__closure ?? this._closure;
+` : "";
+  const asyncPrefix = fnNode.async ? "async " : "";
+  const genPrefix = fnNode.generator ? "*" : "";
+  const fnName = name || "_worklet";
+  const fullFn = `${asyncPrefix}function${genPrefix} ${fnName}(${rawParams}) {
+${unpacker}${rawBody}
+}`;
+  const transformed = (0, import_oxc_transform.transformSync)("worklet.ts", fullFn);
+  assertTransformed(transformed, name, "serialized");
+  return transformed.code.trim();
+}
+function buildLocalFunction(fnNode, code, name) {
+  let rawParams = "";
+  if (fnNode.params && fnNode.params.length > 0) {
+    const pStart = fnNode.params[0].start;
+    const pEnd = fnNode.params[fnNode.params.length - 1].end;
+    rawParams = code.slice(pStart, pEnd);
+  }
+  let rawBody = "";
+  if (fnNode.body.type === "BlockStatement") {
+    const bodyStart = (0, import_autoworklet.bodyStartAfterDirectives)(fnNode, code);
+    const bodyEnd = fnNode.body.end - 1;
+    rawBody = code.slice(bodyStart, bodyEnd);
+  } else {
+    rawBody = code.slice(fnNode.body.start, fnNode.body.end);
+  }
+  let rawFn = "";
+  const asyncPrefix = fnNode.async ? "async " : "";
+  const genPrefix = fnNode.generator ? "*" : "";
+  if (fnNode.type === "ArrowFunctionExpression") {
+    if (fnNode.body.type === "BlockStatement") {
+      rawFn = `${asyncPrefix}(${rawParams}) => {
+${rawBody}
+}`;
+    } else {
+      rawFn = `${asyncPrefix}(${rawParams}) => (${rawBody})`;
+    }
+  } else {
+    rawFn = `${asyncPrefix}function${genPrefix} ${name || "_worklet"}(${rawParams}) {
+${rawBody}
+}`;
+  }
+  const transformed = (0, import_oxc_transform.transformSync)("local.ts", rawFn);
+  assertTransformed(transformed, name, "local");
+  return transformed.code.trim().replace(/;$/, "");
+}