@fluixi/compiler 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/transform/props.cjs

@@ -1,3 +1,441 @@
-"use strict";var $=Object.create;var h=Object.defineProperty;var L=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var F=Object.getPrototypeOf,V=Object.prototype.hasOwnProperty;var J=(e,n)=>{for(var t in n)h(e,t,{get:n[t],enumerable:!0})},D=(e,n,t,s)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of T(n))!V.call(e,r)&&r!==t&&h(e,r,{get:()=>n[r],enumerable:!(s=L(n,r))||s.enumerable});return e};var U=(e,n,t)=>(t=e!=null?$(F(e)):{},D(n||!e||!e.__esModule?h(t,"default",{value:e,enumerable:!0}):t,e)),W=e=>D(h({},"__esModule",{value:!0}),e);var Q={};J(Q,{collectPropsEdits:()=>M,transformProps:()=>K});module.exports=W(Q);var A=require("@babel/parser"),C=U(require("magic-string"),1);function l(e,n){if(e)switch(e.type){case"Identifier":n.add(e.name);return;case"ObjectPattern":for(let t of e.properties)t.type==="RestElement"?l(t.argument,n):l(t.value,n);return;case"ArrayPattern":for(let t of e.elements)l(t,n);return;case"AssignmentPattern":l(e.left,n);return;case"RestElement":l(e.argument,n);return}}function P(e){switch(e.type){case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":case"NullLiteral":case"BigIntLiteral":case"RegExpLiteral":case"Identifier":return!0;case"Literal":return!0;case"TemplateLiteral":return e.expressions.every(P);case"UnaryExpression":return P(e.argument);case"MemberExpression":return!1;default:return!1}}function b(e,n){if(!(!e||typeof e!="object")){n(e);for(let t of Object.keys(e)){if(t==="loc"||t==="range"||t==="leadingComments"||t==="trailingComments")continue;let s=e[t];if(Array.isArray(s))for(let r of s)r&&typeof r=="object"&&b(r,n);else s&&typeof s=="object"&&typeof s.type=="string"&&b(s,n)}}}function Z(e){let n=new Set;return b(e,t=>{if(t.type==="AssignmentExpression")l(t.left,n);else if(t.type==="UpdateExpression"){let s=t.argument;s?.type==="Identifier"&&n.add(s.name)}}),n}function _(e,n){let t=new Set,s=r=>{let u=new Set;l(r,u);for(let c of u)n.has(c)&&t.add(c)};return b(e,r=>{switch(r.type){case"VariableDeclarator":s(r.id);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":s(r.id);for(let u of r.params??[])s(u);return;case"CatchClause":s(r.param);return;case"ClassDeclaration":case"ClassExpression":s(r.id);return}}),t}function E(e,n,t){for(let s of e.properties??[]){if(s.type==="RestElement"){let d=s.argument;if(d?.type!=="Identifier"||n.length>0){let f=new Set;l(d,f);for(let w of f)t.bails.push({name:w,reason:"rest"});continue}t.rest={name:d.name,keys:[]};continue}if(s.computed){let d=new Set;l(s.value,d);for(let f of d)t.bails.push({name:f,reason:"computed"});continue}let r=s.key,u=r.type==="Identifier"?r.name:r.value,c=s.value,a;c.type==="AssignmentPattern"&&(a=c.right,c=c.left);let i=[...n,u];if(c.type==="Identifier"){if(a&&!P(a)){t.bails.push({name:c.name,reason:"unsafe-default"});continue}t.reads.push({name:c.name,path:i,...a?{fallback:a}:{}});continue}if(c.type==="ObjectPattern"){if(a){let d=new Set;l(c,d);for(let f of d)t.bails.push({name:f,reason:"unsafe-default"});continue}E(c,i,t);continue}let N=new Set;l(c,N);for(let d of N)t.bails.push({name:d,reason:"computed"})}}function v(e,n){let t={reads:[],bails:[]};if(e?.type!=="ObjectPattern"||(E(e,[],t),t.rest&&(n?.type!=="BlockStatement"?(t.bails.push({name:t.rest.name,reason:"rest"}),delete t.rest):t.rest.keys=(e.properties??[]).filter(a=>a.type!=="RestElement"&&!a.computed).map(a=>{let i=a.key;return i.type==="Identifier"?i.name:i.value})),t.reads.length===0&&!t.rest))return t;let s=new Set(t.reads.map(a=>a.name));t.rest&&s.add(t.rest.name);let r=Z(n),u=_(n,s),c=[];for(let a of t.reads)r.has(a.name)?t.bails.push({name:a.name,reason:"reassigned"}):u.has(a.name)?t.bails.push({name:a.name,reason:"shadowed"}):c.push(a);return t.reads=c,t.rest&&r.has(t.rest.name)?(t.bails.push({name:t.rest.name,reason:"reassigned"}),delete t.rest):t.rest&&u.has(t.rest.name)&&(t.bails.push({name:t.rest.name,reason:"shadowed"}),delete t.rest),t}function R(e){switch(e){case"rest":return"this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";case"computed":return"the property is not known until it runs";case"reassigned":return"the binding is assigned to, and props are read-only";case"shadowed":return"an inner scope binds the same name";case"unsafe-default":return"the default would have to run again on every read"}}function g(e,n){if(e)switch(e.type){case"Identifier":n.add(e.name);return;case"ObjectPattern":for(let t of e.properties)t.type==="RestElement"?g(t.argument,n):g(t.value,n);return;case"ArrayPattern":for(let t of e.elements)g(t,n);return;case"AssignmentPattern":g(e.left,n);return;case"RestElement":g(e.argument,n);return}}function j(e,n){switch(e.type){case"ImportDeclaration":for(let t of e.specifiers)g(t.local,n);return;case"VariableDeclaration":for(let t of e.declarations)g(t.id,n);return;case"FunctionDeclaration":case"ClassDeclaration":g(e.id,n);return;case"ExportNamedDeclaration":case"ExportDefaultDeclaration":e.declaration&&j(e.declaration,n);return}}function O(e){let n=new Set;for(let t of e.body)j(t,n);return n}function y(e,n,t=null){if(!(!e||typeof e!="object"||typeof e.type!="string")&&!e.type.startsWith("TS")&&n(e,t)!==!1)for(let s of Object.keys(e)){if(s==="loc"||s==="leadingComments"||s==="trailingComments")continue;let r=e[s];if(Array.isArray(r))for(let u of r)y(u,n,e);else r&&typeof r=="object"&&y(r,n,e)}}function I(e){return!!e&&e[0]>="A"&&e[0]<="Z"}function q(e){let n=[];return y(e,t=>{if(t.type==="FunctionDeclaration"&&I(t.id?.name)){n.push(t);return}if(t.type==="VariableDeclarator"&&I(t.id?.name)){let s=t.init;s&&(s.type==="ArrowFunctionExpression"||s.type==="FunctionExpression")&&n.push(s)}}),n}function z(e){let n=new Set;return y(e,t=>{t.type==="Identifier"&&n.add(t.name)}),n}function G(e,n){if(!n)return!0;switch(n.type){case"MemberExpression":case"OptionalMemberExpression":return!(n.property===e&&!n.computed);case"ObjectProperty":case"ObjectMethod":case"ClassProperty":case"ClassMethod":return!(n.key===e&&!n.computed);case"LabeledStatement":case"BreakStatement":case"ContinueStatement":return n.label!==e;case"ImportSpecifier":case"ExportSpecifier":return!1;default:return!0}}function M(e,n,t={}){let s=[],r=[],u=new Set;for(let c of q(e)){let a=c.params?.[0];if(a?.type!=="ObjectPattern")continue;let i=v(a,c.body);for(let o of i.bails)r.push({name:o.name,reason:o.reason,message:R(o.reason),start:a.start});if(i.bails.length>0||i.reads.length===0&&!i.rest)continue;let N=z(c),d=t.parameterName??"props";for(;N.has(d);)d=`_${d}`;let f=new Map;for(let o of i.reads){let p=`${d}.${o.path.join(".")}`,m=o.fallback;f.set(o.name,m?`(${p} === undefined ? ${n.slice(m.start,m.end)} : ${p})`:p)}let w=a.typeAnnotation;if(s.push({start:a.start,end:w?.start??a.end,code:d}),i.rest){let o=i.rest.keys.map(m=>JSON.stringify(m)).join(", "),p=c.body;s.push({start:p.start+1,end:p.start+1,code:`
-  const [, ${i.rest.name}] = splitProps(${d}, [${o}]);`}),u.add("splitProps")}let k=[];y(c.body,(o,p)=>{if(o.type!=="Identifier")return;let m=f.get(o.name);if(!m)return;let x=p?.type==="ObjectProperty"&&p.shorthand&&p.value===o;if(!x&&!G(o,p))return;let S=i.reads.find(B=>B.name===o.name).path;k.push({node:o,parent:x?p:null,text:m,property:S[S.length-1]})});for(let o of k)o.parent?s.push({start:o.parent.start,end:o.parent.end,code:`${o.node.name}: ${o.text}`}):s.push({start:o.node.start,end:o.node.end,code:o.text}),H(o.node,d,o.property)}return{edits:s,diagnostics:r,used:u}}function H(e,n,t){e.type="MemberExpression",e.computed=!1,e.optional=!1,e.object={type:"Identifier",name:n,start:e.start,end:e.start},e.property={type:"Identifier",name:t,start:e.end,end:e.end},delete e.name}function K(e,n="module.tsx",t={}){let s=(0,A.parse)(e,{sourceType:"module",plugins:["typescript","jsx"],errorRecovery:!0}),{edits:r,diagnostics:u,used:c}=M(s.program,e,t),a=new C.default(e);for(let i of r)i.start===i.end?a.appendLeft(i.start,i.code):a.overwrite(i.start,i.end,i.code);return c.has("splitProps")&&!O(s.program).has("splitProps")&&a.prepend(`import { splitProps } from ${JSON.stringify(t.runtimeModule??"@fluixi/dom")};
-`),{code:a.toString(),map:a.generateMap({source:n,includeContent:!0,hires:!0}),diagnostics:u,rewritten:r.filter(i=>i.code!==(t.parameterName??"props")).length}}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/transform/props.ts
+var props_exports = {};
+__export(props_exports, {
+  collectPropsEdits: () => collectPropsEdits,
+  transformProps: () => transformProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_parser = require("@babel/parser");
+var import_magic_string = __toESM(require("magic-string"), 1);
+
+// src/analyze/props-destructure.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function isSafeDefault(node) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+    case "Identifier":
+      return true;
+    // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return node.expressions.every(isSafeDefault);
+    case "UnaryExpression":
+      return isSafeDefault(node.argument);
+    case "MemberExpression":
+      return false;
+    default:
+      return false;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "range" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item && typeof item === "object") walk(item, visit);
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+function reassignedNames(body) {
+  const written = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "AssignmentExpression") patternNames(node.left, written);
+    else if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      if (arg?.type === "Identifier") written.add(arg.name);
+    }
+  });
+  return written;
+}
+function shadowedNames(body, candidates) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const note = (node) => {
+    const names = /* @__PURE__ */ new Set();
+    patternNames(node, names);
+    for (const n of names) if (candidates.has(n)) shadowed.add(n);
+  };
+  walk(body, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        note(node.id);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        note(node.id);
+        for (const p of node.params ?? []) note(p);
+        return;
+      case "CatchClause":
+        note(node.param);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        note(node.id);
+        return;
+    }
+  });
+  return shadowed;
+}
+function collect(pattern, path, plan) {
+  for (const property of pattern.properties ?? []) {
+    if (property.type === "RestElement") {
+      const argument = property.argument;
+      if (argument?.type !== "Identifier" || path.length > 0) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(argument, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "rest" });
+        continue;
+      }
+      plan.rest = { name: argument.name, keys: [] };
+      continue;
+    }
+    if (property.computed) {
+      const names2 = /* @__PURE__ */ new Set();
+      patternNames(property.value, names2);
+      for (const name of names2) plan.bails.push({ name, reason: "computed" });
+      continue;
+    }
+    const key = property.key;
+    const propertyName = key.type === "Identifier" ? key.name : key.value;
+    let value = property.value;
+    let fallback;
+    if (value.type === "AssignmentPattern") {
+      fallback = value.right;
+      value = value.left;
+    }
+    const here = [...path, propertyName];
+    if (value.type === "Identifier") {
+      if (fallback && !isSafeDefault(fallback)) {
+        plan.bails.push({ name: value.name, reason: "unsafe-default" });
+        continue;
+      }
+      plan.reads.push({ name: value.name, path: here, ...fallback ? { fallback } : {} });
+      continue;
+    }
+    if (value.type === "ObjectPattern") {
+      if (fallback) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(value, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "unsafe-default" });
+        continue;
+      }
+      collect(value, here, plan);
+      continue;
+    }
+    const names = /* @__PURE__ */ new Set();
+    patternNames(value, names);
+    for (const name of names) plan.bails.push({ name, reason: "computed" });
+  }
+}
+function planPropsDestructure(pattern, body) {
+  const plan = { reads: [], bails: [] };
+  if (pattern?.type !== "ObjectPattern") return plan;
+  collect(pattern, [], plan);
+  if (plan.rest) {
+    if (body?.type !== "BlockStatement") {
+      plan.bails.push({ name: plan.rest.name, reason: "rest" });
+      delete plan.rest;
+    } else {
+      plan.rest.keys = (pattern.properties ?? []).filter((p) => p.type !== "RestElement" && !p.computed).map((p) => {
+        const key = p.key;
+        return key.type === "Identifier" ? key.name : key.value;
+      });
+    }
+  }
+  if (plan.reads.length === 0 && !plan.rest) return plan;
+  const candidates = new Set(plan.reads.map((r) => r.name));
+  if (plan.rest) candidates.add(plan.rest.name);
+  const written = reassignedNames(body);
+  const shadowed = shadowedNames(body, candidates);
+  const kept = [];
+  for (const read of plan.reads) {
+    if (written.has(read.name)) plan.bails.push({ name: read.name, reason: "reassigned" });
+    else if (shadowed.has(read.name)) plan.bails.push({ name: read.name, reason: "shadowed" });
+    else kept.push(read);
+  }
+  plan.reads = kept;
+  if (plan.rest && written.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "reassigned" });
+    delete plan.rest;
+  } else if (plan.rest && shadowed.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "shadowed" });
+    delete plan.rest;
+  }
+  return plan;
+}
+function explainBail(reason) {
+  switch (reason) {
+    case "rest":
+      return "this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";
+    case "computed":
+      return "the property is not known until it runs";
+    case "reassigned":
+      return "the binding is assigned to, and props are read-only";
+    case "shadowed":
+      return "an inner scope binds the same name";
+    case "unsafe-default":
+      return "the default would have to run again on every read";
+  }
+}
+
+// src/transform/bindings.ts
+function patternNames2(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames2(p.argument, out);
+        else patternNames2(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames2(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames2(node.left, out);
+      return;
+    case "RestElement":
+      patternNames2(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames2(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames2(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames2(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}
+
+// src/transform/props.ts
+function walk2(root, visit, parent = null) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  if (root.type.startsWith("TS")) return;
+  if (visit(root, parent) === false) return;
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) walk2(item, visit, root);
+    } else if (value && typeof value === "object") {
+      walk2(value, visit, root);
+    }
+  }
+}
+function isComponentName(name) {
+  return !!name && name[0] >= "A" && name[0] <= "Z";
+}
+function componentFunctions(program) {
+  const found = [];
+  walk2(program, (node) => {
+    if (node.type === "FunctionDeclaration" && isComponentName(node.id?.name)) {
+      found.push(node);
+      return;
+    }
+    if (node.type === "VariableDeclarator" && isComponentName(node.id?.name)) {
+      const init = node.init;
+      if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) found.push(init);
+    }
+  });
+  return found;
+}
+function usedNames(fn) {
+  const names = /* @__PURE__ */ new Set();
+  walk2(fn, (node) => {
+    if (node.type === "Identifier") names.add(node.name);
+  });
+  return names;
+}
+function isReferencePosition(node, parent) {
+  if (!parent) return true;
+  switch (parent.type) {
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return !(parent.property === node && !parent.computed);
+    case "ObjectProperty":
+    case "ObjectMethod":
+    case "ClassProperty":
+    case "ClassMethod":
+      return !(parent.key === node && !parent.computed);
+    case "LabeledStatement":
+    case "BreakStatement":
+    case "ContinueStatement":
+      return parent.label !== node;
+    case "ImportSpecifier":
+    case "ExportSpecifier":
+      return false;
+    default:
+      return true;
+  }
+}
+function collectPropsEdits(program, code, options = {}) {
+  const edits = [];
+  const diagnostics = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const fn of componentFunctions(program)) {
+    const pattern = fn.params?.[0];
+    if (pattern?.type !== "ObjectPattern") continue;
+    const plan = planPropsDestructure(pattern, fn.body);
+    for (const b of plan.bails) {
+      diagnostics.push({ name: b.name, reason: b.reason, message: explainBail(b.reason), start: pattern.start });
+    }
+    if (plan.bails.length > 0) continue;
+    if (plan.reads.length === 0 && !plan.rest) continue;
+    const taken = usedNames(fn);
+    let parameter = options.parameterName ?? "props";
+    while (taken.has(parameter)) parameter = `_${parameter}`;
+    const replacement = /* @__PURE__ */ new Map();
+    for (const read of plan.reads) {
+      const access = `${parameter}.${read.path.join(".")}`;
+      const fallback = read.fallback;
+      replacement.set(
+        read.name,
+        fallback ? `(${access} === undefined ? ${code.slice(fallback.start, fallback.end)} : ${access})` : access
+      );
+    }
+    const annotation = pattern.typeAnnotation;
+    edits.push({ start: pattern.start, end: annotation?.start ?? pattern.end, code: parameter });
+    if (plan.rest) {
+      const keys = plan.rest.keys.map((k) => JSON.stringify(k)).join(", ");
+      const body = fn.body;
+      edits.push({
+        start: body.start + 1,
+        end: body.start + 1,
+        code: `
+  const [, ${plan.rest.name}] = splitProps(${parameter}, [${keys}]);`
+      });
+      used.add("splitProps");
+    }
+    const matches = [];
+    walk2(fn.body, (node, parent) => {
+      if (node.type !== "Identifier") return void 0;
+      const text = replacement.get(node.name);
+      if (!text) return void 0;
+      const shorthand = parent?.type === "ObjectProperty" && parent.shorthand && parent.value === node;
+      if (!shorthand && !isReferencePosition(node, parent)) return void 0;
+      const path = plan.reads.find((r) => r.name === node.name).path;
+      matches.push({ node, parent: shorthand ? parent : null, text, property: path[path.length - 1] });
+      return void 0;
+    });
+    for (const match of matches) {
+      if (match.parent) {
+        edits.push({ start: match.parent.start, end: match.parent.end, code: `${match.node.name}: ${match.text}` });
+      } else {
+        edits.push({ start: match.node.start, end: match.node.end, code: match.text });
+      }
+      asMemberRead(match.node, parameter, match.property);
+    }
+  }
+  return { edits, diagnostics, used };
+}
+function asMemberRead(node, parameter, property) {
+  node.type = "MemberExpression";
+  node.computed = false;
+  node.optional = false;
+  node.object = { type: "Identifier", name: parameter, start: node.start, end: node.start };
+  node.property = { type: "Identifier", name: property, start: node.end, end: node.end };
+  delete node["name"];
+}
+function transformProps(code, filename = "module.tsx", options = {}) {
+  const ast = (0, import_parser.parse)(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    errorRecovery: true
+  });
+  const { edits, diagnostics, used } = collectPropsEdits(ast.program, code, options);
+  const source = new import_magic_string.default(code);
+  for (const e of edits) {
+    if (e.start === e.end) source.appendLeft(e.start, e.code);
+    else source.overwrite(e.start, e.end, e.code);
+  }
+  if (used.has("splitProps") && !moduleBindings(ast.program).has("splitProps")) {
+    source.prepend(`import { splitProps } from ${JSON.stringify(options.runtimeModule ?? "@fluixi/dom")};
+`);
+  }
+  return {
+    code: source.toString(),
+    map: source.generateMap({ source: filename, includeContent: true, hires: true }),
+    diagnostics,
+    rewritten: edits.filter((e) => e.code !== (options.parameterName ?? "props")).length
+  };
+}

package/dist/transform/props.d.cts

@@ -0,0 +1,45 @@
+import MagicString from 'magic-string';
+import { type DestructureBail } from '../analyze/props-destructure.cjs';
+export interface PropsDiagnostic {
+    /** The binding we couldn't rewrite. */
+    name: string;
+    reason: DestructureBail;
+    /** Sentence for the message. */
+    message: string;
+    /** Character offset of the pattern it came from. */
+    start: number;
+}
+export interface PropsTransformOptions {
+    /** Name to give the props parameter. @default 'props' */
+    parameterName?: string;
+    /** Module `splitProps` is imported from when a rest needs it. @default '@fluixi/dom' */
+    runtimeModule?: string;
+}
+export interface PropsTransformResult {
+    code: string;
+    map: ReturnType<MagicString['generateMap']>;
+    diagnostics: PropsDiagnostic[];
+    /** How many bindings were rewritten. Zero means the source came back untouched. */
+    rewritten: number;
+}
+/** One span to replace. Same shape the template transform uses for its own edits. */
+export interface PropsEdit {
+    start: number;
+    end: number;
+    code: string;
+}
+export interface PropsEditsResult {
+    edits: PropsEdit[];
+    diagnostics: PropsDiagnostic[];
+    /** Runtime symbols the emitted code needs — `splitProps`, when a pattern had a rest. */
+    used: Set<string>;
+}
+/**
+ * Work out the edits without applying them, so a caller that already has the source in a
+ * MagicString can fold them into its own. That's how the template transform picks this
+ * up: one string, one map, and holes get the rewrite because it slices them with the
+ * edits applied.
+ */
+export declare function collectPropsEdits(program: unknown, code: string, options?: PropsTransformOptions): PropsEditsResult;
+/** Run the rewrite on its own. The template transform folds the edits in instead. */
+export declare function transformProps(code: string, filename?: string, options?: PropsTransformOptions): PropsTransformResult;