svelte-origin 1.0.0-next.21 → 1.0.0-next.23

package/dist/plugin.js

@@ -1969,6 +1969,7 @@ function transformOriginDefinition(content, svelteImports) {
   let attrsContent = "";
   let contentWithoutAttrs = bodyContent;
   let attrPropertyName = "props";
+  let propsRef = null;
   if (attrsMatch) {
     attrPropertyName = attrsMatch[1];
     const attrsStart = attrsMatch.index;
@@ -1999,13 +2000,31 @@ function transformOriginDefinition(content, svelteImports) {
       }
       contentWithoutAttrs = bodyContent.slice(0, attrsStart) + bodyContent.slice(cutEnd);
     }
+  } else {
+    const externalRefMatch = bodyContent.match(/(\w+)\s*:\s*(\w+)\s*,/);
+    if (externalRefMatch) {
+      const propName = externalRefMatch[1];
+      const refName = externalRefMatch[2];
+      if ((propName === "props" || propName === "attrs") && /^[A-Z]/.test(refName) && !["$state", "$derived", "$effect", "$bindable"].includes(refName)) {
+        attrPropertyName = propName;
+        propsRef = refName;
+        const refStart = externalRefMatch.index;
+        const refEnd = refStart + externalRefMatch[0].length;
+        contentWithoutAttrs = bodyContent.slice(0, refStart) + bodyContent.slice(refEnd);
+      }
+    }
   }
   const attrDetails = parseAttrsSource(attrsContent);
   const { body: createFnBody, attachments } = transformOriginBody(contentWithoutAttrs.trim(), parents, attrDetails, attrPropertyName, svelteImports);
   const parentsCode = parents.length > 0 ? `[${parents.join(", ")}]` : "undefined";
   let configCode = `{
 	__attrSchema: ${attrSchemaCode},
-	__parents: ${parentsCode},
+	__parents: ${parentsCode},`;
+  if (propsRef) {
+    configCode += `
+	__propsRef: ${propsRef},`;
+  }
+  configCode += `
 	__create: (__inputAttrs${parents.length > 0 ? ", __super" : ""}) => {
 ${createFnBody}
 	}`;
@@ -2240,6 +2259,73 @@ function parseOriginSchemaFromSource(source, exportName) {
     return compiledResult;
   return null;
 }
+function parseAttrsSchemaFromSource(source, exportName) {
+  const sourceResult = parseSourceAttrs(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledAttrs(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceAttrs(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$attrs\\s*\\(`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const attrsStart = match.index + match[0].length - 1;
+  const attrsEnd = findMatchingBracket(source, attrsStart);
+  if (attrsEnd === -1)
+    return null;
+  let attrsContent = source.slice(attrsStart + 1, attrsEnd).trim();
+  let parentNames = [];
+  if (attrsContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(attrsContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = attrsContent.slice(1, closeBracket);
+      parentNames = parentsContent.split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+      let i = closeBracket + 1;
+      while (i < attrsContent.length && /[\s,]/.test(attrsContent[i]))
+        i++;
+      attrsContent = attrsContent.slice(i);
+    }
+  }
+  if (!attrsContent.startsWith("{")) {
+    return { attrs: [], parentNames };
+  }
+  const objEnd = findMatchingBracket(attrsContent, 0, "{", "}");
+  if (objEnd === -1)
+    return { attrs: [], parentNames };
+  const objContent = attrsContent.slice(1, objEnd);
+  const attrs = parseAttrsContent(objContent);
+  return { attrs, parentNames };
+}
+function parseCompiledAttrs(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createAttrs\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
 function parseSourceOrigin(source, exportName) {
   const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source);
@@ -2265,6 +2351,13 @@ function parseSourceOrigin(source, exportName) {
   }
   const attrsMatch = bodyContent.match(/(\w+)\s*:\s*\$attrs\s*\(\s*\{/);
   if (!attrsMatch) {
+    const externalRefMatch = bodyContent.match(/(?:props|attrs)\s*:\s*([A-Z]\w*)\b/);
+    if (externalRefMatch) {
+      const propsRef = externalRefMatch[1];
+      if (!["Object", "Array", "String", "Number", "Boolean"].includes(propsRef)) {
+        return { attrs: [], parentNames, propsRef };
+      }
+    }
     return { attrs: [], parentNames };
   }
   const attrsStart = attrsMatch.index;
@@ -2301,7 +2394,9 @@ function parseCompiledOrigin(source, exportName) {
   if (parentsMatch && parentsMatch[1].trim()) {
     parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
   }
-  return { attrs, parentNames };
+  const propsRefMatch = configContent.match(/__propsRef\s*:\s*(\w+)/);
+  const propsRef = propsRefMatch ? propsRefMatch[1] : undefined;
+  return { attrs, parentNames, propsRef };
 }
 function parseCompiledAttrSchema(content) {
   const result = [];
@@ -2741,7 +2836,34 @@ function getElementTypeImport(element) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source, neededImports) {
   let changed = false;
   const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -2807,6 +2929,111 @@ function transformAttrsForCalls(s, source, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element = stringMatch[1];
+      const typeImport = getElementTypeImport(element);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
 
 // src/transform/core.ts
 function transformScript(source, options = {}) {
@@ -2832,7 +3059,7 @@ function transformScript(source, options = {}) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -2903,7 +3130,7 @@ async function transformScriptAsync(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -2973,7 +3200,7 @@ async function transformScriptContent(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);
@@ -3669,6 +3896,58 @@ async function resolveSchema(importPath, exportName, importerId, cache, debug, a
         mergedAttrs.push(attr);
       }
     }
+    if (schema.propsRef) {
+      const propsRefImportPath = findImportPath(source, schema.propsRef);
+      let propsRefSchema = null;
+      if (propsRefImportPath) {
+        if (debug) {
+          console.log(`[svelte-origin] Resolving propsRef: ${schema.propsRef} from import ${propsRefImportPath}`);
+        }
+        propsRefSchema = await resolveAttrsSchema(propsRefImportPath, schema.propsRef, filePath, cache, debug, aliases);
+      } else {
+        if (debug) {
+          console.log(`[svelte-origin] Resolving propsRef: ${schema.propsRef} from same file`);
+        }
+        propsRefSchema = parseAttrsSchemaFromSource(source, schema.propsRef);
+        if (propsRefSchema && propsRefSchema.parentNames.length > 0) {
+          const resolvedParentAttrs = [];
+          for (const parentName of propsRefSchema.parentNames) {
+            const parentImportPath = findImportPath(source, parentName);
+            let parentSchema = null;
+            if (parentImportPath) {
+              parentSchema = await resolveAttrsSchema(parentImportPath, parentName, filePath, cache, debug, aliases);
+            } else {
+              parentSchema = parseAttrsSchemaFromSource(source, parentName);
+            }
+            if (parentSchema) {
+              for (const attr of parentSchema.attrs) {
+                const existingIndex = resolvedParentAttrs.findIndex((a) => a.key === attr.key);
+                if (existingIndex === -1) {
+                  resolvedParentAttrs.push(attr);
+                }
+              }
+            }
+          }
+          for (const attr of propsRefSchema.attrs) {
+            const existingIndex = resolvedParentAttrs.findIndex((a) => a.key === attr.key);
+            if (existingIndex !== -1) {
+              resolvedParentAttrs[existingIndex] = attr;
+            } else {
+              resolvedParentAttrs.push(attr);
+            }
+          }
+          propsRefSchema = { attrs: resolvedParentAttrs, parentNames: propsRefSchema.parentNames };
+        }
+      }
+      if (propsRefSchema) {
+        for (const attr of propsRefSchema.attrs) {
+          const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+          if (existingIndex === -1) {
+            mergedAttrs.push(attr);
+          }
+        }
+      }
+    }
     const mergedSchema = {
       attrs: mergedAttrs,
       parentNames: schema.parentNames
@@ -3686,6 +3965,75 @@ async function resolveSchema(importPath, exportName, importerId, cache, debug, a
     return null;
   }
 }
+async function resolveAttrsSchema(importPath, exportName, importerId, cache, debug, aliases) {
+  const cacheKey = `attrs::${importPath}::${exportName}`;
+  if (cache.has(cacheKey)) {
+    if (debug) {
+      console.log(`[svelte-origin] Cache hit for ${cacheKey}`);
+    }
+    return cache.get(cacheKey) || null;
+  }
+  try {
+    const importerDir = dirname2(importerId);
+    if (debug) {
+      console.log(`[svelte-origin] Resolving attrs: ${exportName} from ${importPath}`);
+    }
+    const resolvedPath = resolveImportPath(importPath, aliases, importerDir);
+    if (!resolvedPath) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const filePath = resolveFilePath(resolvedPath);
+    if (!filePath) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const source = readFileSync2(filePath, "utf-8");
+    const schema = parseAttrsSchemaFromSource(source, exportName);
+    if (!schema) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const mergedAttrs = [];
+    for (const parentName of schema.parentNames) {
+      const parentImportPath = findImportPath(source, parentName);
+      if (parentImportPath) {
+        const parentSchema = await resolveAttrsSchema(parentImportPath, parentName, filePath, cache, debug, aliases);
+        if (parentSchema) {
+          for (const attr of parentSchema.attrs) {
+            const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+            if (existingIndex === -1) {
+              mergedAttrs.push(attr);
+            }
+          }
+        }
+      }
+    }
+    for (const attr of schema.attrs) {
+      const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+      if (existingIndex !== -1) {
+        mergedAttrs[existingIndex] = attr;
+      } else {
+        mergedAttrs.push(attr);
+      }
+    }
+    const mergedSchema = {
+      attrs: mergedAttrs,
+      parentNames: schema.parentNames
+    };
+    if (debug) {
+      console.log(`[svelte-origin] Resolved attrs schema for ${exportName}:`, mergedSchema.attrs.map((a) => a.key));
+    }
+    cache.set(cacheKey, mergedSchema);
+    return mergedSchema;
+  } catch (error) {
+    if (debug) {
+      console.error(`[svelte-origin] Error resolving attrs schema for ${importPath}:`, error);
+    }
+    cache.set(cacheKey, null);
+    return null;
+  }
+}
 var plugin_default = svelteOrigin;
 export {
   svelteOrigin,