babel-plugin-essor 0.0.16 → 0.0.17-beta.2

package/dist/index.js

@@ -59,7 +59,6 @@ var IMPORTS_MAPS = [
   "reactive",
   "memoEffect",
   "omitProps",
-  "resolveDefaultProps",
   // component
   "createComponent",
   "Fragment",
@@ -81,9 +80,7 @@ var IMPORTS_MAPS = [
   "addEventListener",
   // rendering related
   "render",
-  "toRawHtmlString",
-  "toEscapedHtmlString",
-  "markAsRawHtml",
+  "escape",
   "escapeHTML",
   "getHydrationKey",
   "hydrationAnchor",
@@ -111,31 +108,13 @@ var HYDRATE_IMPORT_REMAPS = {
   patchAttr: "patchAttrHydrate",
   patchStyle: "patchStyleHydrate"
 };
-var SERVER_ONLY_NAMES = [
-  "render",
-  "toRawHtmlString",
-  "toEscapedHtmlString",
-  "markAsRawHtml",
-  "escapeHTML",
-  "Fragment",
-  "Portal",
-  "Suspense",
-  "getHydrationKey",
-  "ssrAttr",
-  "ssrBind",
-  "ssrClass",
-  "ssrSelected",
-  "ssrStyle",
-  "ssrSpread",
-  "ssrTextValue",
-  "createComponent",
-  "patchAttr"
-];
-var _remaps = SERVER_IMPORT_REMAPS;
-var SERVER_EXPORTS = new Set(SERVER_ONLY_NAMES.map((name) => {
-  var _a;
-  return (_a = _remaps[name]) != null ? _a : name;
-}));
+var UNIVERSAL_IMPORTS = /* @__PURE__ */ new Set([
+  "signal",
+  "computed",
+  "reactive",
+  "memoEffect",
+  "omitProps"
+]);
 var importMap = Object.fromEntries(IMPORTS_MAPS.map((name) => [name, name]));
 var TRANSFORM_PROPERTY_NAME = "__props";
 var FRAGMENT_NAME = "Fragment";
@@ -222,7 +201,7 @@ function computeDeclarationCacheKey(expression) {
   const parts = [];
   for (const el of expression.elements) {
     if (el == null) {
-      parts.push("\0null");
+      parts.push(" null");
       continue;
     }
     if (types.isStringLiteral(el)) {
@@ -255,23 +234,26 @@ function createImport(path) {
   const ctx = getCompileContext();
   if (!ctx.imports.size) return;
   const { mode } = ctx.options;
-  const serverSpecifiers = [];
-  const clientSpecifiers = [];
-  for (const name of ctx.imports) {
-    const local = ctx.importIdentifiers[name];
-    const importedName = resolveImportedName(name, mode);
-    const specifier = types.importSpecifier(local, types.identifier(importedName));
-    if (mode === "server" /* SERVER */ && SERVER_EXPORTS.has(importedName)) {
-      serverSpecifiers.push(specifier);
-    } else {
-      clientSpecifiers.push(specifier);
-    }
-  }
-  if (serverSpecifiers.length > 0) {
-    path.node.body.unshift(types.importDeclaration(serverSpecifiers, types.stringLiteral("essor/server")));
-  }
-  if (clientSpecifiers.length > 0) {
-    path.node.body.unshift(types.importDeclaration(clientSpecifiers, types.stringLiteral("essor")));
+  const emit = (names, source) => {
+    if (!names.length) return;
+    const specifiers = names.map(
+      (name) => types.importSpecifier(
+        ctx.importIdentifiers[name],
+        types.identifier(resolveImportedName(name, mode))
+      )
+    );
+    path.node.body.unshift(types.importDeclaration(specifiers, types.stringLiteral(source)));
+  };
+  if (mode === "server" /* SERVER */) {
+    const universal = [];
+    const server = [];
+    for (const name of ctx.imports) {
+      (UNIVERSAL_IMPORTS.has(name) ? universal : server).push(name);
+    }
+    emit(server, "essor/server");
+    emit(universal, "essor");
+  } else {
+    emit([...ctx.imports], "essor");
   }
 }
 
@@ -819,29 +801,55 @@ function applyHmr(programPath, ctx) {
     ])
   );
 }
-function isMemberAccessingProperty(node, propertyName) {
-  if (!node.computed && types.isIdentifier(node.property) && node.property.name === propertyName) {
-    return true;
-  }
-  if (node.computed && types.isStringLiteral(node.property) && node.property.value === propertyName) {
-    return true;
+var DEFAULT_PREFIX = "$";
+var cachedContext = null;
+var cachedPrefix = DEFAULT_PREFIX;
+function getSignalPrefix() {
+  var _a;
+  const ctx = getCompileContext();
+  if (ctx !== cachedContext) {
+    cachedContext = ctx;
+    cachedPrefix = (_a = ctx.options.signalPrefix) != null ? _a : DEFAULT_PREFIX;
   }
-  return false;
+  return cachedPrefix;
 }
 function isSignal(name) {
-  var _a;
-  const prefix = (_a = getCompileContext().options.signalPrefix) != null ? _a : "$";
-  return !!name && x(name, prefix);
+  return !!name && x(name, getSignalPrefix());
+}
+function stripSignalPrefix(name) {
+  const prefix = getSignalPrefix();
+  return x(name, prefix) ? name.slice(prefix.length) : name;
+}
+function isMemberLike(node) {
+  return types.isMemberExpression(node) || types.isOptionalMemberExpression(node);
+}
+function isMemberAccessingProperty(node, propertyName) {
+  if (node.computed) {
+    return types.isStringLiteral(node.property) && node.property.value === propertyName;
+  }
+  return types.isIdentifier(node.property) && node.property.name === propertyName;
+}
+function clone(node) {
+  return types.cloneNode(node, true);
+}
+function valueAccess(object) {
+  return types.memberExpression(object, types.identifier("value"));
+}
+function makeComputed(access) {
+  return types.callExpression(useImport("computed"), [types.arrowFunctionExpression([], access)]);
 }
 function replaceSymbol(path) {
   const { init, id } = path.node;
-  if (!types.isIdentifier(id)) return;
-  if (!isSignal(id.name)) return;
-  if (isAlreadySignalCall(init)) return;
+  if (types.isObjectPattern(id) || types.isArrayPattern(id)) {
+    transformDestructuring(path);
+    return;
+  }
+  if (!types.isIdentifier(id) || !isSignal(id.name) || isAlreadySignalCall(init)) return;
   const isComputed = isFunctionLikeExpression(init) && path.parent.kind === "const";
-  const importName = isComputed ? "computed" : "signal";
-  const args = init ? [init] : [];
-  path.node.init = types.callExpression(useImport(importName), args);
+  path.node.init = types.callExpression(
+    useImport(isComputed ? "computed" : "signal"),
+    init ? [init] : []
+  );
 }
 function isAlreadySignalCall(init) {
   if (!init || !types.isCallExpression(init) || !types.isIdentifier(init.callee)) return false;
@@ -850,24 +858,151 @@ function isAlreadySignalCall(init) {
   const { importIdentifiers } = getCompileContext();
   return calleeName === importIdentifiers.signal.name || calleeName === importIdentifiers.computed.name;
 }
+function transformDestructuring(path) {
+  var _a;
+  const { init, id } = path.node;
+  const pattern = id;
+  if (!init) {
+    if (patternHasSignalBinding(pattern)) path.skip();
+    return;
+  }
+  if (!isSignalSource(init) && !patternHasSignalBinding(pattern)) return;
+  const declPath = path.parentPath;
+  if (!declPath || !declPath.isVariableDeclaration()) return;
+  if ((_a = declPath.parentPath) == null ? void 0 : _a.isForStatement()) {
+    path.skip();
+    return;
+  }
+  const declarators = bindPattern(pattern, signalSourceBase(init));
+  const declaration = declPath.node;
+  const index = declaration.declarations.indexOf(path.node);
+  declaration.declarations.splice(index, 1, ...declarators);
+  path.skip();
+}
+function isSignalSource(init) {
+  if (types.isIdentifier(init)) return isSignal(init.name);
+  if (isMemberLike(init) && types.isIdentifier(init.object) && isSignal(init.object.name)) {
+    return isMemberAccessingProperty(init, "value");
+  }
+  return false;
+}
+function signalSourceBase(init) {
+  if (types.isIdentifier(init) && isSignal(init.name)) {
+    return valueAccess(types.identifier(init.name));
+  }
+  return clone(init);
+}
+function patternHasSignalBinding(node) {
+  if (types.isIdentifier(node)) return isSignal(node.name);
+  if (types.isObjectPattern(node)) {
+    return node.properties.some(
+      (p2) => types.isRestElement(p2) ? patternHasSignalBinding(p2.argument) : patternHasSignalBinding(p2.value)
+    );
+  }
+  if (types.isArrayPattern(node)) {
+    return node.elements.some((el) => el != null && patternHasSignalBinding(el));
+  }
+  if (types.isAssignmentPattern(node)) return patternHasSignalBinding(node.left);
+  if (types.isRestElement(node)) return patternHasSignalBinding(node.argument);
+  return false;
+}
+function bindPattern(pattern, base) {
+  return types.isObjectPattern(pattern) ? bindObjectPattern(pattern, base) : bindArrayPattern(pattern, base);
+}
+function bindObjectPattern(pattern, base) {
+  const out = [];
+  const handledKeys = [];
+  for (const prop of pattern.properties) {
+    if (types.isRestElement(prop)) {
+      out.push(buildObjectRest(prop, base, handledKeys));
+      continue;
+    }
+    const { keyExpr, computed, target } = resolveObjectProp(prop);
+    handledKeys.push({ key: clone(keyExpr), computed });
+    out.push(...bindTarget(target, types.memberExpression(clone(base), keyExpr, computed)));
+  }
+  return out;
+}
+function resolveObjectProp(prop) {
+  const target = prop.value;
+  const shorthandId = types.isAssignmentPattern(target) ? target.left : target;
+  if (prop.shorthand && types.isIdentifier(shorthandId) && isSignal(shorthandId.name)) {
+    return { keyExpr: types.identifier(stripSignalPrefix(shorthandId.name)), computed: false, target };
+  }
+  if (prop.computed) {
+    return { keyExpr: prop.key, computed: true, target };
+  }
+  return { keyExpr: prop.key, computed: !types.isIdentifier(prop.key), target };
+}
+function bindArrayPattern(pattern, base) {
+  const out = [];
+  pattern.elements.forEach((el, i2) => {
+    if (el == null) return;
+    if (types.isRestElement(el)) {
+      const slice = types.callExpression(types.memberExpression(clone(base), types.identifier("slice")), [
+        types.numericLiteral(i2)
+      ]);
+      out.push(...bindTarget(el.argument, slice));
+      return;
+    }
+    out.push(...bindTarget(el, types.memberExpression(clone(base), types.numericLiteral(i2), true)));
+  });
+  return out;
+}
+function bindTarget(target, access) {
+  if (types.isAssignmentPattern(target)) {
+    return bindTarget(target.left, applyDefault(access, target.right));
+  }
+  if (types.isIdentifier(target)) {
+    const value = isSignal(target.name) ? makeComputed(access) : access;
+    return [types.variableDeclarator(types.identifier(target.name), value)];
+  }
+  if (types.isObjectPattern(target)) return bindObjectPattern(target, access);
+  if (types.isArrayPattern(target)) return bindArrayPattern(target, access);
+  return [types.variableDeclarator(target, access)];
+}
+function applyDefault(access, def) {
+  return types.conditionalExpression(
+    types.binaryExpression("===", clone(access), types.identifier("undefined")),
+    def,
+    clone(access)
+  );
+}
+function buildObjectRest(rest, base, handledKeys) {
+  const omits = (target) => types.objectPattern([
+    ...handledKeys.map(({ key, computed }) => types.objectProperty(key, genUid("_omit$"), computed)),
+    types.restElement(target)
+  ]);
+  const arg = rest.argument;
+  if (types.isIdentifier(arg) && isSignal(arg.name)) {
+    const inner = genUid("_rest$");
+    const body = types.blockStatement([
+      types.variableDeclaration("const", [types.variableDeclarator(omits(inner), clone(base))]),
+      types.returnStatement(clone(inner))
+    ]);
+    return types.variableDeclarator(types.identifier(arg.name), makeComputed(body));
+  }
+  return types.variableDeclarator(omits(arg), clone(base));
+}
 function symbolIdentifier(path) {
-  const name = path.node.name;
+  const { name } = path.node;
   if (!isSignal(name)) return;
-  if (!shouldProcessIdentifier(path, path.parentPath)) return;
+  if (!shouldProcessIdentifier(path)) return;
   if (isAlreadyValueAccess(path)) return;
   const parent = path.parent;
-  if (types.isMemberExpression(parent) && parent.property === path.node) return;
-  path.replaceWith(types.memberExpression(types.identifier(name), types.identifier("value")));
+  if (isMemberLike(parent) && parent.property === path.node && !parent.computed) return;
+  path.replaceWith(valueAccess(types.identifier(name)));
   path.skip();
 }
-function shouldProcessIdentifier(path, parentPath) {
+function shouldProcessIdentifier(path) {
+  const parentPath = path.parentPath;
   if (!parentPath) return false;
   const parent = parentPath.node;
   const node = path.node;
-  if (types.isVariableDeclarator(parent) || types.isArrayPattern(parent) || types.isObjectPattern(parent)) {
+  if (types.isVariableDeclarator(parent) || types.isArrayPattern(parent) || types.isObjectPattern(parent) || types.isRestElement(parent)) {
     return false;
   }
-  if (types.isImportSpecifier(parent) || types.isImportDefaultSpecifier(parent) || types.isImportNamespaceSpecifier(parent)) {
+  if (types.isImportSpecifier(parent) || types.isImportDefaultSpecifier(parent) || types.isImportNamespaceSpecifier(parent) || types.isExportSpecifier(parent)) {
     return false;
   }
   if (types.isFunctionDeclaration(parent) || types.isFunctionExpression(parent)) {
@@ -878,7 +1013,7 @@ function shouldProcessIdentifier(path, parentPath) {
   }
   if (types.isClassDeclaration(parent) && parent.id === node) return false;
   if (types.isObjectMethod(parent) || types.isClassMethod(parent)) return false;
-  if (types.isObjectProperty(parent) && parent.key === node) return false;
+  if (types.isObjectProperty(parent) && parent.key === node && !parent.computed) return false;
   if (types.isLabeledStatement(parent) && parent.label === node) return false;
   if ((types.isBreakStatement(parent) || types.isContinueStatement(parent)) && parent.label === node) {
     return false;
@@ -887,38 +1022,27 @@ function shouldProcessIdentifier(path, parentPath) {
 }
 function isAlreadyValueAccess(path) {
   const parent = path.parent;
-  if (types.isMemberExpression(parent) && parent.object === path.node) {
+  if (isMemberLike(parent) && parent.object === path.node) {
     return isMemberAccessingProperty(parent, "value");
   }
   if (!types.isParenthesizedExpression(parent) && !types.isTSAsExpression(parent) && !types.isTSNonNullExpression(parent)) {
     return false;
   }
   const ancestor = path.findParent((p2) => {
-    if (!p2.isMemberExpression()) return false;
-    const m = p2.node;
-    return m.object === path.node && isMemberAccessingProperty(m, "value");
+    if (!isMemberLike(p2.node)) return false;
+    return isMemberAccessingProperty(p2.node, "value");
   });
   return !!ancestor;
 }
 function symbolAssignment(path) {
   const { left } = path.node;
-  if (!types.isIdentifier(left)) return;
-  if (!isSignal(left.name)) return;
-  if (isAlreadyValueAssignment(left)) return;
-  path.node.left = types.memberExpression(types.identifier(left.name), types.identifier("value"));
-}
-function isAlreadyValueAssignment(left) {
-  return types.isMemberExpression(left) && isMemberAccessingProperty(left, "value");
+  if (!types.isIdentifier(left) || !isSignal(left.name)) return;
+  path.node.left = valueAccess(types.identifier(left.name));
 }
 function symbolUpdate(path) {
   const { argument } = path.node;
-  if (!types.isIdentifier(argument)) return;
-  if (!isSignal(argument.name)) return;
-  if (isAlreadyValueUpdate(argument)) return;
-  path.node.argument = types.memberExpression(types.identifier(argument.name), types.identifier("value"));
-}
-function isAlreadyValueUpdate(argument) {
-  return types.isMemberExpression(argument) && isMemberAccessingProperty(argument, "value");
+  if (!types.isIdentifier(argument) || !isSignal(argument.name)) return;
+  path.node.argument = valueAccess(types.identifier(argument.name));
 }
 var symbolVisitors = {
   VariableDeclarator: replaceSymbol,
@@ -926,114 +1050,174 @@ var symbolVisitors = {
   AssignmentExpression: symbolAssignment,
   UpdateExpression: symbolUpdate
 };
-function transformProperty(path, properties, parentPath, defaults = {}) {
-  for (const property of properties) {
-    if (!types.isObjectProperty(property)) continue;
-    const key = property.key;
-    const keyName = types.isIdentifier(key) ? key.name : types.isStringLiteral(key) ? key.value : "";
-    if (!keyName) continue;
-    const value = property.value;
-    const childPath = `${parentPath}.${keyName}`;
-    if (types.isAssignmentPattern(value)) {
-      const left = value.left;
-      if (types.isIdentifier(left)) {
-        defaults[keyName] = value.right;
-        path.scope.rename(left.name, childPath);
-      } else if (types.isObjectPattern(left)) {
-        transformProperty(path, left.properties, childPath, defaults);
-        defaults[keyName] = value.right;
-      }
-    } else if (types.isIdentifier(value)) {
-      path.scope.rename(value.name, childPath);
-    } else if (types.isObjectPattern(value)) {
-      const nested = {};
-      transformProperty(path, value.properties, childPath, nested);
-      if (Object.keys(nested).length > 0) defaults[keyName] = nested;
-    }
-  }
-  return defaults;
-}
-function buildRestVariableDeclaration(restName, parentPath, excludeProps) {
-  const validExcludeProps = excludeProps.filter(Boolean);
-  const pathParts = parentPath.split(".").filter(Boolean);
-  let sourceObject = types.identifier(pathParts[0] || "__props");
-  for (let i2 = 1; i2 < pathParts.length; i2++) {
-    sourceObject = types.memberExpression(sourceObject, types.identifier(pathParts[i2]));
-  }
-  const init = validExcludeProps.length === 0 ? sourceObject : types.callExpression(useImport(importMap.omitProps), [
-    sourceObject,
-    types.arrayExpression(validExcludeProps.map((name) => types.stringLiteral(name)))
+function clone2(node) {
+  return types.cloneNode(node, true);
+}
+function applyDefault2(access, def) {
+  return types.conditionalExpression(
+    types.binaryExpression("===", clone2(access), types.identifier("undefined")),
+    def,
+    clone2(access)
+  );
+}
+function resolveKey(prop) {
+  const key = prop.key;
+  if (prop.computed) {
+    return { keyExpr: key, computed: true, excludeKey: key };
+  }
+  if (types.isIdentifier(key)) {
+    return {
+      keyExpr: types.identifier(key.name),
+      computed: false,
+      excludeKey: types.stringLiteral(key.name)
+    };
+  }
+  if (types.isStringLiteral(key)) {
+    return {
+      keyExpr: types.stringLiteral(key.value),
+      computed: true,
+      excludeKey: types.stringLiteral(key.value)
+    };
+  }
+  if (types.isNumericLiteral(key)) {
+    return {
+      keyExpr: types.numericLiteral(key.value),
+      computed: true,
+      excludeKey: types.stringLiteral(String(key.value))
+    };
+  }
+  return { keyExpr: key, computed: true, excludeKey: null };
+}
+function restName(argument) {
+  return types.isIdentifier(argument) ? argument.name : null;
+}
+function buildObjectRestInit(base, excludeKeys) {
+  if (excludeKeys.length === 0) return clone2(base);
+  return types.callExpression(useImport(importMap.omitProps), [
+    clone2(base),
+    types.arrayExpression(excludeKeys.map((key) => clone2(key)))
   ]);
-  return types.variableDeclaration("const", [types.variableDeclarator(types.identifier(restName), init)]);
 }
-function transformRestProperties(path, restProperties, notRestNames = []) {
-  if (!types.isIdentifier(restProperties.argument)) return;
-  const restName = restProperties.argument.name;
-  if (notRestNames.length === 0) {
-    path.node.params[0] = types.identifier(restName);
+function collectTarget(target, access, leaves, rests) {
+  if (types.isAssignmentPattern(target)) {
+    collectTarget(target.left, applyDefault2(access, target.right), leaves, rests);
     return;
   }
-  const declaration = buildRestVariableDeclaration(restName, TRANSFORM_PROPERTY_NAME, notRestNames);
-  const body = path.node.body;
-  body.body.unshift(declaration);
-}
-function buildDefaultValueObject(defaults) {
-  if (!P(defaults)) return types.objectExpression([]);
-  const properties = [];
-  for (const [key, value] of Object.entries(defaults)) {
-    if (!key) continue;
-    let propertyValue;
-    if (P(value) && !types.isNode(value)) {
-      propertyValue = buildDefaultValueObject(value);
-    } else if (types.isExpression(value)) {
-      propertyValue = value;
-    } else {
+  if (types.isIdentifier(target)) {
+    leaves.push({ name: target.name, accessor: access });
+    return;
+  }
+  if (types.isObjectPattern(target)) {
+    collectObjectPattern(target, access, leaves, rests);
+    return;
+  }
+  if (types.isArrayPattern(target)) {
+    collectArrayPattern(target, access, leaves, rests);
+    return;
+  }
+}
+function collectObjectPattern(pattern, base, leaves, rests) {
+  const excludeKeys = [];
+  for (const prop of pattern.properties) {
+    if (types.isRestElement(prop)) {
+      const name = restName(prop.argument);
+      if (name) rests.push({ name, init: buildObjectRestInit(base, excludeKeys) });
       continue;
     }
-    properties.push(types.objectProperty(types.identifier(key), propertyValue));
-  }
-  return types.objectExpression(properties);
+    const { keyExpr, computed, excludeKey } = resolveKey(prop);
+    if (excludeKey !== null) excludeKeys.push(excludeKey);
+    const access = types.memberExpression(clone2(base), keyExpr, computed);
+    collectTarget(prop.value, access, leaves, rests);
+  }
+}
+function spreadOf(base) {
+  return types.arrayExpression([types.spreadElement(clone2(base))]);
+}
+function collectArrayPattern(pattern, base, leaves, rests) {
+  pattern.elements.forEach((element, index) => {
+    if (element == null) return;
+    if (types.isRestElement(element)) {
+      const name = restName(element.argument);
+      if (name) {
+        const init = types.callExpression(types.memberExpression(spreadOf(base), types.identifier("slice")), [
+          types.numericLiteral(index)
+        ]);
+        rests.push({ name, init });
+      }
+      return;
+    }
+    const access = types.memberExpression(spreadOf(base), types.numericLiteral(index), true);
+    collectTarget(element, access, leaves, rests);
+  });
 }
-function buildDefaultValue(path, defaults) {
-  path.node.params[0] = types.identifier(TRANSFORM_PROPERTY_NAME);
-  if (Object.keys(defaults).length === 0) return;
-  const resolveDefaultProps = useImport(importMap.resolveDefaultProps);
-  const body = types.isBlockStatement(path.node.body) ? path.node.body : types.blockStatement([types.returnStatement(path.node.body)]);
-  path.node.body = body;
-  body.body.unshift(
-    types.expressionStatement(
-      types.assignmentExpression(
-        "=",
-        types.identifier(TRANSFORM_PROPERTY_NAME),
-        types.callExpression(resolveDefaultProps, [
-          types.identifier(TRANSFORM_PROPERTY_NAME),
-          buildDefaultValueObject(defaults)
-        ])
-      )
-    )
-  );
+function ensureBlockBody(path) {
+  if (types.isBlockStatement(path.node.body)) return path.node.body;
+  const block = types.blockStatement([types.returnStatement(path.node.body)]);
+  path.node.body = block;
+  return block;
+}
+function isInsidePattern(ref, pattern) {
+  return !!ref.findParent((p2) => p2.node === pattern);
+}
+function accessorFor(pattern, base, name) {
+  var _a;
+  const leaves = [];
+  collectObjectPattern(pattern, base, leaves, []);
+  return (_a = leaves.find((leaf) => leaf.name === name)) == null ? void 0 : _a.accessor;
 }
 function transformFnProps(path) {
+  var _a, _b;
   const firstParam = path.node.params[0];
   if (!firstParam || !types.isObjectPattern(firstParam) || !checkHasJSXReturn(path)) return;
   const ctx = getCompileContext();
-  const properties = firstParam.properties;
   const signalPrefix = ctx.options.signalPrefix || "$";
-  const notRestProperties = properties.filter((prop) => !types.isRestElement(prop));
-  const restProperties = properties.find((prop) => types.isRestElement(prop));
-  const notRestNames = notRestProperties.map((prop) => types.isIdentifier(prop.key) ? prop.key.name : null).filter((name) => name !== null);
-  const signalConflicts = notRestNames.filter((name) => x(name, signalPrefix));
-  if (signalConflicts.length > 0) {
-    re("transformProps", "Property names cannot start with signal prefix", signalConflicts);
-  }
-  if (notRestProperties.length > 0) {
-    const defaults = transformProperty(path, notRestProperties, TRANSFORM_PROPERTY_NAME);
-    if (restProperties) transformRestProperties(path, restProperties, notRestNames);
-    buildDefaultValue(path, defaults);
+  const base = types.identifier(TRANSFORM_PROPERTY_NAME);
+  const initLeaves = [];
+  const initRests = [];
+  collectObjectPattern(firstParam, base, initLeaves, initRests);
+  const conflicts = [...initLeaves, ...initRests].map((b2) => b2.name).filter((name) => x(name, signalPrefix));
+  if (conflicts.length > 0) {
+    re("transformProps", "Property names cannot start with signal prefix", conflicts);
+  }
+  if (initLeaves.length === 0 && initRests.length === 1 && firstParam.properties.length === 1 && types.isRestElement(firstParam.properties[0])) {
+    path.node.params[0] = types.identifier(initRests[0].name);
     return;
   }
-  buildDefaultValue(path, {});
-  if (restProperties) transformRestProperties(path, restProperties, notRestNames);
+  const inPatternRefs = /* @__PURE__ */ new Map();
+  const bodyRefs = /* @__PURE__ */ new Map();
+  for (const leaf of initLeaves) {
+    const inside = [];
+    const outside = [];
+    for (const ref of (_b = (_a = path.scope.getBinding(leaf.name)) == null ? void 0 : _a.referencePaths) != null ? _b : []) {
+      (isInsidePattern(ref, firstParam) ? inside : outside).push(ref);
+    }
+    if (inside.length > 0) inPatternRefs.set(leaf.name, inside);
+    bodyRefs.set(leaf.name, outside);
+  }
+  for (const leaf of initLeaves) {
+    const refs = inPatternRefs.get(leaf.name);
+    if (!refs) continue;
+    const accessor = accessorFor(firstParam, base, leaf.name);
+    if (!accessor) continue;
+    for (const ref of refs) ref.replaceWith(clone2(accessor));
+  }
+  const leaves = [];
+  const rests = [];
+  collectObjectPattern(firstParam, base, leaves, rests);
+  const accessorByName = new Map(leaves.map((leaf) => [leaf.name, leaf.accessor]));
+  path.node.params[0] = types.identifier(TRANSFORM_PROPERTY_NAME);
+  for (const [name, refs] of bodyRefs) {
+    const accessor = accessorByName.get(name);
+    if (!accessor) continue;
+    for (const ref of refs) ref.replaceWith(clone2(accessor));
+  }
+  if (rests.length > 0) {
+    const body = ensureBlockBody(path);
+    const declarations = rests.map(
+      (rest) => types.variableDeclaration("const", [types.variableDeclarator(types.identifier(rest.name), rest.init)])
+    );
+    body.body.unshift(...declarations);
+  }
 }
 var propsVisitors = {
   FunctionDeclaration: transformFnProps,
@@ -1449,8 +1633,8 @@ function setNodeText(path, text) {
 function createComponentPropKey(name, forceStringLiteralKeys = false) {
   return forceStringLiteralKeys || !types.isValidIdentifier(name) ? types.stringLiteral(name) : types.identifier(name);
 }
-function cloneValue(value, clone = false) {
-  return clone ? types.cloneNode(value, true) : value;
+function cloneValue(value, clone3 = false) {
+  return clone3 ? types.cloneNode(value, true) : value;
 }
 function createPropNode(name, value, kind, options) {
   const key = createComponentPropKey(name, options.forceStringLiteralKeys);
@@ -1596,44 +1780,6 @@ var SERVER_TEXT_ESCAPES = {
   ">": "&gt;"
 };
 var serverTextEscapeRE = /[&<>]/g;
-function markSafeHtmlCall(expression) {
-  return types.callExpression(useImport("markAsRawHtml"), [expression]);
-}
-function isGeneratedServerHtmlCall(expression) {
-  const { importIdentifiers } = getCompileContext();
-  const renderId = importIdentifiers.render;
-  const componentId = importIdentifiers.createComponent;
-  return types.isIdentifier(expression.callee) && (expression.callee.name === renderId.name || expression.callee.name === componentId.name);
-}
-function visitServerHtmlSubexpressions(node) {
-  var _a;
-  if (!node) return node;
-  if (types.isJSXElement(node) || types.isJSXFragment(node)) {
-    return markSafeHtmlCall(node);
-  }
-  if (types.isCallExpression(node) && isGeneratedServerHtmlCall(node)) {
-    return markSafeHtmlCall(node);
-  }
-  const keys = (_a = types.VISITOR_KEYS[node.type]) != null ? _a : [];
-  for (const key of keys) {
-    const record = node;
-    const value = record[key];
-    if (Array.isArray(value)) {
-      for (let i2 = 0; i2 < value.length; i2++) {
-        const child = value[i2];
-        if (child && typeof child === "object" && "type" in child) {
-          value[i2] = visitServerHtmlSubexpressions(child);
-        }
-      }
-    } else if (value && typeof value === "object" && "type" in value) {
-      record[key] = visitServerHtmlSubexpressions(value);
-    }
-  }
-  return node;
-}
-function markServerHtmlSubexpressions(expression) {
-  return visitServerHtmlSubexpressions(expression);
-}
 function escapeServerTemplateText(value) {
   return value.replaceAll(serverTextEscapeRE, (char) => {
     var _a;
@@ -1718,14 +1864,50 @@ function createSSRSelectedExpression(selectValue, optionValue) {
     types.cloneNode(optionValue, true)
   ]);
 }
+function isSafeServerHtml(expr) {
+  if (types.isJSXElement(expr) || types.isJSXFragment(expr)) return true;
+  if (!types.isCallExpression(expr) || !types.isIdentifier(expr.callee)) return false;
+  const { importIdentifiers } = getCompileContext();
+  return expr.callee.name === importIdentifiers.render.name || expr.callee.name === importIdentifiers.createComponent.name;
+}
+function escapeChildExpression(expr) {
+  if (isSafeServerHtml(expr)) {
+    return expr;
+  }
+  if (types.isParenthesizedExpression(expr)) {
+    expr.expression = escapeChildExpression(expr.expression);
+    return expr;
+  }
+  if (types.isLogicalExpression(expr)) {
+    if (expr.operator === "&&") {
+      expr.right = escapeChildExpression(expr.right);
+    } else {
+      expr.left = escapeChildExpression(expr.left);
+      expr.right = escapeChildExpression(expr.right);
+    }
+    return expr;
+  }
+  if (types.isConditionalExpression(expr)) {
+    expr.consequent = escapeChildExpression(expr.consequent);
+    expr.alternate = escapeChildExpression(expr.alternate);
+    return expr;
+  }
+  if (types.isSequenceExpression(expr) && expr.expressions.length > 0) {
+    const last = expr.expressions.length - 1;
+    expr.expressions[last] = escapeChildExpression(expr.expressions[last]);
+    return expr;
+  }
+  return types.callExpression(useImport("escape"), [expr]);
+}
 function generateServerNode(node, ctx, withHydrationKey = true) {
   switch (node.type) {
     case 2 /* TEXT */:
       return types.stringLiteral(node.value);
     case 3 /* EXPRESSION */: {
-      const expression = node.asRawChildren ? types.cloneNode(node.value, true) : markServerHtmlSubexpressions(types.cloneNode(node.value, true));
-      const converter = node.asRawChildren ? "toRawHtmlString" : "toEscapedHtmlString";
-      return types.callExpression(useImport(converter), [expression]);
+      if (node.asRawChildren) {
+        return types.cloneNode(node.value, true);
+      }
+      return escapeChildExpression(types.cloneNode(node.value, true));
     }
     case 1 /* COMPONENT */:
       return generateServerComponent(node, ctx);