@saastro/studio 0.1.0

package/dist/chunk-QTXHBNZQ.js

@@ -0,0 +1,959 @@
+// src/vite/auto-wrap.ts
+var FRONTMATTER_RE = /^\s*---\s*\n([\s\S]*?)\n---\s*\n/;
+var SAASTRO_ATTR_RE = /data-saastro/;
+var FIELD_PREFIX_REFERENCE_RE = /\bfieldPrefix\b/;
+var FIRST_OPEN_TAG_RE = /<([a-zA-Z][a-zA-Z0-9]*)\b([^<>]*?)\s*(\/?)>/;
+var INJECTION = ' {...(fieldPrefix ? { "data-saastro": `sec:${fieldPrefix}`, draggable: "true" } : {})}';
+function transformAstroSource(source) {
+  const fm = FRONTMATTER_RE.exec(source);
+  if (!fm) return source;
+  if (!FIELD_PREFIX_REFERENCE_RE.test(fm[1])) return source;
+  const template = source.slice(fm[0].length);
+  const tagMatch = FIRST_OPEN_TAG_RE.exec(template);
+  if (!tagMatch) return source;
+  const tagName = tagMatch[1];
+  if (tagName[0] !== tagName[0].toLowerCase()) return source;
+  const existingAttrs = tagMatch[2];
+  if (SAASTRO_ATTR_RE.test(existingAttrs)) return source;
+  const selfClose = tagMatch[3];
+  const replacement = `<${tagName}${existingAttrs}${INJECTION}${selfClose ? " " + selfClose : ""}>`;
+  const templateInjected = template.slice(0, tagMatch.index) + replacement + template.slice(tagMatch.index + tagMatch[0].length);
+  return source.slice(0, fm[0].length) + templateInjected;
+}
+
+// ../studio-core/dist/component-schema/index.js
+import {
+  Project
+} from "ts-morph";
+import { Project as Project2 } from "ts-morph";
+var STUDIO_DIRECTIVE_KINDS = /* @__PURE__ */ new Set([
+  "string",
+  "textarea",
+  "image-url",
+  "enum",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "json"
+]);
+var STUDIO_DIRECTIVE_RE = /@studio:([A-Za-z][A-Za-z0-9-]*)/g;
+var IMAGE_NAME_HINTS = /(^|_)(image|img|avatar|logo|icon|thumbnail|photo|picture|cover|background)($|_)/i;
+var IMAGE_SUFFIX_HINTS = /_(url|src)$/i;
+var FRONTMATTER_RE2 = /^\s*---\s*\n([\s\S]*?)\n---/;
+function extractFrontmatter(astroSource) {
+  const m = FRONTMATTER_RE2.exec(astroSource);
+  return m ? m[1] ?? "" : null;
+}
+function extractComponentSchema(astroSource, options = {}) {
+  const frontmatter = extractFrontmatter(astroSource);
+  if (frontmatter == null) return null;
+  const project = options.project ?? createProject();
+  const virtualName = options.componentPath ? `${options.componentPath}.frontmatter.ts` : "component.frontmatter.ts";
+  let sourceFile;
+  try {
+    sourceFile = project.createSourceFile(virtualName, frontmatter, {
+      overwrite: true
+    });
+  } catch {
+    return null;
+  }
+  let propsDecl = sourceFile.getInterface("Props");
+  if (!propsDecl) {
+    propsDecl = sourceFile.getTypeAlias("Props");
+  }
+  if (!propsDecl) {
+    sourceFile.delete();
+    return null;
+  }
+  const propsType = propsDecl.getType();
+  const fields = [];
+  for (const prop of propsType.getProperties()) {
+    const field = describeProperty(prop, propsDecl);
+    if (field) fields.push(field);
+  }
+  applyDefaultsFromDestructuring(frontmatter, fields);
+  sourceFile.delete();
+  return {
+    fields,
+    componentPath: options.componentPath,
+    version: 1
+  };
+}
+function createProject() {
+  return new Project({
+    useInMemoryFileSystem: true,
+    skipFileDependencyResolution: true,
+    compilerOptions: {
+      strict: true,
+      // Match the customer's typical Astro tsconfig — ESNext + node16
+      // resolution covers most setups. Misses are non-fatal: unresolved
+      // imports surface as `'json'` kind with a description.
+      target: 99,
+      module: 199,
+      moduleResolution: 100,
+      allowSyntheticDefaultImports: true,
+      esModuleInterop: true,
+      skipLibCheck: true
+    }
+  });
+}
+function describeProperty(prop, parent) {
+  const name = prop.getName();
+  const declarations = prop.getDeclarations();
+  const decl = declarations[0];
+  if (!decl) return null;
+  const isQuestionToken = decl.hasQuestionToken?.() ?? false;
+  const propsSourceFile = parent.getSourceFile();
+  const type = prop.getTypeAtLocation(propsSourceFile);
+  const optional = isQuestionToken || typeIncludes(type, (t) => t.isUndefined());
+  const directive = readStudioDirective(decl);
+  if (type.isBoolean() || stripUndefined(type).isBoolean()) {
+    return applyDirective({ name, kind: "boolean", optional }, directive, type);
+  }
+  const nonNullishParts = type.isUnion() ? type.getUnionTypes().filter((t) => !t.isUndefined() && !t.isNull()) : [type];
+  if (nonNullishParts.length >= 1 && nonNullishParts.every((t) => t.isStringLiteral())) {
+    const enumValues = nonNullishParts.map(
+      (t) => String(t.getLiteralValue())
+    );
+    if (enumValues.length === 1) {
+      const f = describeType(name, nonNullishParts[0]);
+      return applyDirective(
+        { ...f, optional: f.optional || optional },
+        directive,
+        type
+      );
+    }
+    return applyDirective(
+      { name, kind: "enum", optional, enumValues },
+      directive,
+      type
+    );
+  }
+  if (nonNullishParts.length === 1) {
+    const f = describeType(name, nonNullishParts[0]);
+    return applyDirective(
+      { ...f, optional: f.optional || optional },
+      directive,
+      type
+    );
+  }
+  return applyDirective(
+    {
+      name,
+      kind: "json",
+      optional,
+      description: `unparsed: ${type.getText()}`
+    },
+    directive,
+    type
+  );
+}
+function readStudioDirective(decl) {
+  const sources = [];
+  const jsDocable = decl;
+  if (typeof jsDocable.getJsDocs === "function") {
+    for (const doc of jsDocable.getJsDocs()) {
+      sources.push(doc.getText());
+    }
+  }
+  if (sources.length === 0) {
+    const ranges = decl.getLeadingCommentRanges?.() ?? [];
+    for (const range of ranges) {
+      const text = range.getText();
+      if (text.includes("@studio:")) sources.push(text);
+    }
+  }
+  for (const source of sources) {
+    STUDIO_DIRECTIVE_RE.lastIndex = 0;
+    let match;
+    while ((match = STUDIO_DIRECTIVE_RE.exec(source)) !== null) {
+      const raw = match[1];
+      if (!raw) continue;
+      const kind = raw === "image" ? "image-url" : raw;
+      if (STUDIO_DIRECTIVE_KINDS.has(kind)) return kind;
+    }
+  }
+  return null;
+}
+function applyDirective(field, directive, type) {
+  if (!directive) return field;
+  if (!isDirectiveCompatible(directive, type)) return field;
+  if (field.kind === directive) return field;
+  return { ...field, kind: directive };
+}
+function isDirectiveCompatible(directive, type) {
+  if (directive === "json") return true;
+  const stripped = stripUndefined(type);
+  const nonNullishParts = type.isUnion() ? type.getUnionTypes().filter((t) => !t.isUndefined() && !t.isNull()) : [stripped];
+  switch (directive) {
+    case "string":
+    case "textarea":
+    case "image-url":
+      return nonNullishParts.every((t) => t.isString() || t.isStringLiteral());
+    case "enum":
+      return nonNullishParts.every((t) => t.isString() || t.isStringLiteral());
+    case "number":
+      return nonNullishParts.every((t) => t.isNumber() || t.isNumberLiteral());
+    case "boolean":
+      return type.isBoolean() || stripped.isBoolean();
+    case "array":
+      return nonNullishParts.every((t) => t.isArray());
+    case "object":
+      return nonNullishParts.every((t) => isDescendableObject(t));
+    default:
+      return false;
+  }
+}
+var NON_DESCENDABLE_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "RegExp",
+  "Date",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Error",
+  "URL",
+  "URLSearchParams",
+  "ArrayBuffer",
+  "Uint8Array"
+]);
+function isCallable(type) {
+  return type.getCallSignatures().length > 0;
+}
+function isDescendableObject(type) {
+  if (!type.isObject() && !type.isInterface()) return false;
+  if (isCallable(type)) return false;
+  const symbol = type.getSymbol() ?? type.getAliasSymbol();
+  const symbolName = symbol?.getName();
+  if (symbolName && NON_DESCENDABLE_TYPE_NAMES.has(symbolName)) return false;
+  return type.getProperties().length > 0;
+}
+function describeType(name, type) {
+  if (type.isStringLiteral()) {
+    return { name, kind: "string", optional: false };
+  }
+  if (type.isUnion() && type.getUnionTypes().every((t) => t.isStringLiteral())) {
+    const values = type.getUnionTypes().map((t) => String(t.getLiteralValue()));
+    return { name, kind: "enum", optional: false, enumValues: values };
+  }
+  if (type.isString()) {
+    return { name, kind: pickStringKind(name), optional: false };
+  }
+  if (type.isNumber()) return { name, kind: "number", optional: false };
+  if (type.isBoolean()) return { name, kind: "boolean", optional: false };
+  if (type.isArray()) {
+    const elementType = type.getArrayElementType();
+    if (elementType) {
+      const itemDescriptor = describeAnyType("__item__", elementType);
+      return { name, kind: "array", optional: false, items: itemDescriptor };
+    }
+    return { name, kind: "array", optional: false };
+  }
+  if (isDescendableObject(type)) {
+    const fields = [];
+    for (const sub of type.getProperties()) {
+      const subDecl = sub.getDeclarations()[0];
+      if (!subDecl) continue;
+      const subType = sub.getTypeAtLocation(subDecl);
+      const subOptional = (subDecl.hasQuestionToken?.() ?? false) || typeIncludes(subType, (t) => t.isUndefined());
+      const sf = describeAnyType(sub.getName(), subType);
+      const subDirective = readStudioDirective(subDecl);
+      fields.push(
+        applyDirective(
+          { ...sf, optional: sf.optional || subOptional },
+          subDirective,
+          subType
+        )
+      );
+    }
+    if (fields.length > 0) {
+      return { name, kind: "object", optional: false, fields };
+    }
+  }
+  return {
+    name,
+    kind: "json",
+    optional: false,
+    description: `unparsed: ${type.getText()}`
+  };
+}
+function describeAnyType(name, type) {
+  const optional = typeIncludes(type, (t) => t.isUndefined());
+  const nonNullishParts = type.isUnion() ? type.getUnionTypes().filter((t) => !t.isUndefined() && !t.isNull()) : [type];
+  if (nonNullishParts.length >= 1 && nonNullishParts.every((t) => t.isStringLiteral())) {
+    if (nonNullishParts.length === 1) {
+      return { ...describeType(name, nonNullishParts[0]), optional };
+    }
+    return {
+      name,
+      kind: "enum",
+      optional,
+      enumValues: nonNullishParts.map((t) => String(t.getLiteralValue()))
+    };
+  }
+  if (nonNullishParts.length === 1) {
+    const f = describeType(name, nonNullishParts[0]);
+    return { ...f, optional: f.optional || optional };
+  }
+  return {
+    name,
+    kind: "json",
+    optional,
+    description: `unparsed: ${type.getText()}`
+  };
+}
+function pickStringKind(name) {
+  if (IMAGE_NAME_HINTS.test(name) || IMAGE_SUFFIX_HINTS.test(name)) {
+    return "image-url";
+  }
+  if (/description|body|content|copy|summary/i.test(name)) {
+    return "textarea";
+  }
+  return "string";
+}
+function typeIncludes(type, predicate) {
+  if (predicate(type)) return true;
+  if (type.isUnion()) {
+    return type.getUnionTypes().some(predicate);
+  }
+  return false;
+}
+function stripUndefined(type) {
+  if (!type.isUnion()) return type;
+  const remaining = type.getUnionTypes().filter((t) => !t.isUndefined() && !t.isNull());
+  return remaining[0] ?? type;
+}
+function applyDefaultsFromDestructuring(frontmatter, fields) {
+  const match = /const\s*\{([\s\S]*?)\}\s*=\s*Astro\.props/.exec(frontmatter);
+  if (!match) return;
+  const body = match[1] ?? "";
+  const entries = splitTopLevel(body, ",");
+  for (const entry of entries) {
+    const eq = entry.indexOf("=");
+    if (eq < 0) continue;
+    const lhs = entry.slice(0, eq).trim();
+    const rhs = entry.slice(eq + 1).trim();
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(lhs)) continue;
+    const target = fields.find((f) => f.name === lhs);
+    if (!target) continue;
+    target.defaultValue = parseLiteral(rhs);
+  }
+}
+function splitTopLevel(s, sep) {
+  const out = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of s) {
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    else if (ch === "}" || ch === "]" || ch === ")") depth--;
+    if (ch === sep && depth === 0) {
+      out.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) out.push(current);
+  return out;
+}
+function parseLiteral(rhs) {
+  const trimmed = rhs.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  const quoted = /^(['"`])([\s\S]*)\1$/.exec(trimmed);
+  if (quoted) return quoted[2];
+  return trimmed;
+}
+
+// src/vite/extract-props-schema.ts
+var CACHE_MAX = 500;
+var cache = /* @__PURE__ */ new Map();
+function hashSource(source) {
+  let h = 5381;
+  for (let i = 0; i < source.length; i++) {
+    h = (h << 5) + h + source.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(16);
+}
+function extractPropsSchema(source, options = {}) {
+  const key = `${options.componentPath ?? ""} ${hashSource(source)}`;
+  if (cache.has(key)) {
+    const cached = cache.get(key) ?? null;
+    cache.delete(key);
+    cache.set(key, cached);
+    return cached;
+  }
+  const schema = extractComponentSchema(source, {
+    componentPath: options.componentPath
+  });
+  if (cache.size >= CACHE_MAX) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(key, schema);
+  return schema;
+}
+
+// src/vite/inject-schema.ts
+var FRONTMATTER_RE3 = /^\s*---\s*\n([\s\S]*?)\n---\s*\n/;
+var SCHEMA_SCRIPT_MARKER = 'type="application/saastro-schema"';
+var FIRST_OPEN_TAG_RE2 = /<([a-zA-Z][a-zA-Z0-9]*)\b([^<>]*?)\s*(\/?)>/;
+function extractFieldPrefixDefault(frontmatter) {
+  const destruct = /const\s*\{([\s\S]*?)\}\s*=\s*Astro\.props/.exec(frontmatter);
+  if (!destruct) return null;
+  const body = destruct[1] ?? "";
+  const m = /\bfieldPrefix\s*=\s*(['"])([^'"\n]*)\1/.exec(body);
+  return m ? m[2] ?? null : null;
+}
+function extractFieldPrefixFromDataAttr(template) {
+  const m = /data-saastro=\{\s*`\s*sec:\$\{\s*fieldPrefix\s*\?\?\s*(['"])([^'"`]*)\1\s*\}/.exec(
+    template
+  );
+  return m ? m[2] ?? null : null;
+}
+function findClosingTag(haystack, tagName, searchFrom) {
+  const re = new RegExp(
+    `<!--[\\s\\S]*?-->|<(/?)${tagName}\\b[^<>]*?(/?)>`,
+    "gi"
+  );
+  re.lastIndex = searchFrom;
+  let depth = 1;
+  while (true) {
+    const m = re.exec(haystack);
+    if (!m) return -1;
+    if (m[0].startsWith("<!--")) continue;
+    const isClose = m[1] === "/";
+    const isSelfClose = m[2] === "/";
+    if (isClose) {
+      depth--;
+      if (depth === 0) return m.index;
+    } else if (!isSelfClose) {
+      depth++;
+    }
+  }
+}
+function encodeSchemaBody(schema) {
+  return JSON.stringify(schema).replace(/<\//g, "<\\/");
+}
+function injectSchema(source, schema, options = {}) {
+  if (source.includes(SCHEMA_SCRIPT_MARKER)) return source;
+  const fm = FRONTMATTER_RE3.exec(source);
+  if (!fm) return source;
+  const frontmatter = fm[1] ?? "";
+  const templateStart = fm[0].length;
+  const template = source.slice(templateStart);
+  const tagMatch = FIRST_OPEN_TAG_RE2.exec(template);
+  if (!tagMatch) return source;
+  const tagName = tagMatch[1];
+  if (tagName[0] !== tagName[0].toLowerCase()) return source;
+  const isSelfClose = tagMatch[3] === "/";
+  if (isSelfClose) return source;
+  const openTagEnd = tagMatch.index + tagMatch[0].length;
+  const closeIdx = findClosingTag(template, tagName, openTagEnd);
+  if (closeIdx < 0) return source;
+  const prefixDefault = options.prefixOverride ?? extractFieldPrefixDefault(frontmatter) ?? extractFieldPrefixFromDataAttr(template);
+  const dataPrefixAttr = prefixDefault != null ? `data-prefix={fieldPrefix ?? ${JSON.stringify(prefixDefault)}}` : `data-prefix={fieldPrefix}`;
+  const scriptTag = `<script type="application/saastro-schema" is:inline ${dataPrefixAttr}>` + encodeSchemaBody(schema) + `</script>`;
+  const newTemplate = template.slice(0, closeIdx) + scriptTag + template.slice(closeIdx);
+  return source.slice(0, templateStart) + newTemplate;
+}
+
+// src/vite/instrument-fields.ts
+var FRONTMATTER_RE4 = /^\s*---\s*\n[\s\S]*?\n---\s*\n/;
+function instrumentFields(source, schema, _options = {}) {
+  if (!schema.fields.length) return source;
+  if (!source.includes("data-saastro=")) return source;
+  const fmMatch = FRONTMATTER_RE4.exec(source);
+  if (!fmMatch) return source;
+  const templateStart = fmMatch[0].length;
+  const template = source.slice(templateStart);
+  const schemaScriptStart = template.indexOf(
+    '<script type="application/saastro-schema"'
+  );
+  let head;
+  let tail;
+  if (schemaScriptStart >= 0) {
+    head = template.slice(0, schemaScriptStart);
+    tail = template.slice(schemaScriptStart);
+  } else {
+    head = template;
+    tail = "";
+  }
+  const transformed = transformTemplate(head, schema.fields);
+  return source.slice(0, templateStart) + transformed + tail;
+}
+function transformTemplate(template, fields) {
+  let out = template;
+  for (const field of fields) {
+    if (field.kind !== "array") continue;
+    out = transformArrayField(out, field);
+  }
+  for (const field of fields) {
+    if (field.kind === "array") continue;
+    out = transformScalarField(out, field.name);
+  }
+  return out;
+}
+function transformArrayField(template, field) {
+  const name = field.name;
+  const subFields = field.items?.fields ?? [];
+  const re = new RegExp(
+    `\\b${escapeReg(name)}\\s*\\.\\s*map\\s*\\(\\s*\\(\\s*([A-Za-z_$][\\w$]*)\\s*(?:,\\s*([A-Za-z_$][\\w$]*)\\s*)?\\)\\s*=>\\s*`,
+    "g"
+  );
+  let result = "";
+  let cursor = 0;
+  let m;
+  while ((m = re.exec(template)) !== null) {
+    const headerStart = m.index;
+    const paramName = m[1];
+    const existingIdx = m[2] ?? null;
+    const arrowEnd = headerStart + m[0].length;
+    const body = readArrowBody(template, arrowEnd);
+    if (!body) continue;
+    let innerJsx = body.bodyText;
+    if (existingIdx && existingIdx !== "__i") {
+      const renameRe = new RegExp(`\\b${escapeReg(existingIdx)}\\b`, "g");
+      innerJsx = innerJsx.replace(renameRe, "__i");
+    }
+    const transformedJsx = stampArrayItem(innerJsx, name, paramName, subFields);
+    const headerNew = `${name}.map((${paramName}, __i) => `;
+    result += template.slice(cursor, headerStart) + headerNew;
+    if (body.parens) {
+      result += "(" + transformedJsx + ")";
+    } else {
+      result += transformedJsx;
+    }
+    const bodyAbsEnd = arrowEnd + body.bodyOffset + body.bodyText.length;
+    const callCloseAbsEnd = arrowEnd + body.totalEndRel;
+    if (body.parens) {
+      const afterBodyParen = bodyAbsEnd + 1;
+      result += template.slice(afterBodyParen, callCloseAbsEnd);
+    } else {
+      result += template.slice(bodyAbsEnd, callCloseAbsEnd);
+    }
+    cursor = callCloseAbsEnd;
+    re.lastIndex = cursor;
+  }
+  result += template.slice(cursor);
+  return result;
+}
+function readArrowBody(template, start) {
+  let i = start;
+  while (i < template.length && /\s/.test(template[i])) i++;
+  if (i >= template.length) return null;
+  let bodyStart;
+  let bodyEnd;
+  let parens;
+  if (template[i] === "(") {
+    parens = true;
+    const inner = readBalanced(template, i, "(", ")");
+    if (inner == null) return null;
+    bodyStart = i + 1;
+    bodyEnd = inner;
+    while (bodyStart < bodyEnd && /\s/.test(template[bodyStart])) bodyStart++;
+    let trimEnd = bodyEnd;
+    while (trimEnd > bodyStart && /\s/.test(template[trimEnd - 1])) trimEnd--;
+    bodyEnd = trimEnd;
+    let j = inner + 1;
+    while (j < template.length && /\s/.test(template[j])) j++;
+    if (template[j] !== ")") return null;
+    j++;
+    return {
+      parens,
+      bodyOffset: bodyStart - start,
+      bodyText: template.slice(bodyStart, bodyEnd),
+      totalEndRel: j - start
+    };
+  }
+  if (template[i] === "<") {
+    parens = false;
+    const elEnd = readJsxElement(template, i);
+    if (elEnd == null) return null;
+    bodyStart = i;
+    bodyEnd = elEnd;
+    let j = bodyEnd;
+    while (j < template.length && /\s/.test(template[j])) j++;
+    if (template[j] !== ")") return null;
+    j++;
+    return {
+      parens,
+      bodyOffset: bodyStart - start,
+      bodyText: template.slice(bodyStart, bodyEnd),
+      totalEndRel: j - start
+    };
+  }
+  return null;
+}
+function readBalanced(s, i, open, close) {
+  if (s[i] !== open) return null;
+  let depth = 0;
+  let j = i;
+  while (j < s.length) {
+    const ch = s[j];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      j = skipString(s, j) + 1;
+      continue;
+    }
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return j;
+    }
+    j++;
+  }
+  return null;
+}
+function skipString(s, i) {
+  const quote = s[i];
+  let j = i + 1;
+  while (j < s.length) {
+    const ch = s[j];
+    if (ch === "\\") {
+      j += 2;
+      continue;
+    }
+    if (quote === "`" && ch === "$" && s[j + 1] === "{") {
+      const close = readBalanced(s, j + 1, "{", "}");
+      if (close == null) return s.length - 1;
+      j = close + 1;
+      continue;
+    }
+    if (ch === quote) return j;
+    j++;
+  }
+  return s.length - 1;
+}
+function readJsxElement(s, start) {
+  if (s[start] !== "<") return null;
+  let i = start + 1;
+  const nameMatch = /^[A-Za-z][A-Za-z0-9]*/.exec(s.slice(i));
+  if (!nameMatch) return null;
+  const tag = nameMatch[0];
+  i += tag.length;
+  let inString = null;
+  let braceDepth = 0;
+  while (i < s.length) {
+    const ch = s[i];
+    if (inString) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (inString === "`" && ch === "$" && s[i + 1] === "{") {
+        const close = readBalanced(s, i + 1, "{", "}");
+        if (close == null) return null;
+        i = close + 1;
+        continue;
+      }
+      if (ch === inString) inString = null;
+      i++;
+      continue;
+    }
+    if (braceDepth > 0) {
+      if (ch === "{") braceDepth++;
+      else if (ch === "}") braceDepth--;
+      else if (ch === '"' || ch === "'" || ch === "`") inString = ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inString = ch;
+      i++;
+      continue;
+    }
+    if (ch === "{") {
+      braceDepth = 1;
+      i++;
+      continue;
+    }
+    if (ch === "/" && s[i + 1] === ">") {
+      return i + 2;
+    }
+    if (ch === ">") {
+      i++;
+      let depth = 1;
+      const re = new RegExp(`<\\/?${tag}\\b`, "g");
+      re.lastIndex = i;
+      while (true) {
+        const m = re.exec(s);
+        if (!m) return null;
+        const isClose = s[m.index + 1] === "/";
+        let k = m.index + (isClose ? 2 + tag.length : 1 + tag.length);
+        let str = null;
+        let bd = 0;
+        while (k < s.length) {
+          const c = s[k];
+          if (str) {
+            if (c === "\\") {
+              k += 2;
+              continue;
+            }
+            if (c === str) str = null;
+            k++;
+            continue;
+          }
+          if (bd > 0) {
+            if (c === "{") bd++;
+            else if (c === "}") bd--;
+            k++;
+            continue;
+          }
+          if (c === '"' || c === "'" || c === "`") {
+            str = c;
+            k++;
+            continue;
+          }
+          if (c === "{") {
+            bd = 1;
+            k++;
+            continue;
+          }
+          if (c === "/" && s[k + 1] === ">") {
+            k += 2;
+            break;
+          }
+          if (c === ">") {
+            k++;
+            break;
+          }
+          k++;
+        }
+        if (isClose) {
+          depth--;
+          if (depth === 0) return k;
+        } else {
+          if (s[k - 2] !== "/") depth++;
+        }
+        re.lastIndex = k;
+      }
+    }
+    i++;
+  }
+  return null;
+}
+function stampArrayItem(jsx, fieldName, paramName, subFields) {
+  let out = stampOuterElement(
+    jsx,
+    `{\`${fieldName}[\${__i}]\`}`
+  );
+  for (const sub of subFields) {
+    const propPath = `{\`${fieldName}[\${__i}].${sub.name}\`}`;
+    out = transformDottedReference(out, paramName, sub.name, propPath);
+  }
+  return out;
+}
+function stampOuterElement(jsx, valueExpr) {
+  const m = /<([A-Za-z][A-Za-z0-9]*)\b([^<>]*?)(\/?)>/.exec(jsx);
+  if (!m) return jsx;
+  if (/data-saastro-field/.test(m[2])) return jsx;
+  const tag = m[1];
+  const attrs = m[2];
+  const selfClose = m[3];
+  const replacement = `<${tag}${attrs} data-saastro-field=${valueExpr}${selfClose}>`;
+  return jsx.slice(0, m.index) + replacement + jsx.slice(m.index + m[0].length);
+}
+function transformScalarField(template, name) {
+  return transformDottedReference(template, name, null, JSON.stringify(name));
+}
+function transformDottedReference(template, paramOrName, subProp, valueAttr) {
+  const refPattern = subProp ? new RegExp(
+    `\\{\\s*${escapeReg(paramOrName)}\\s*\\.\\s*${escapeReg(subProp)}\\s*\\}`,
+    "g"
+  ) : new RegExp(`\\{\\s*${escapeReg(paramOrName)}\\s*\\}`, "g");
+  let out = template;
+  if (!subProp) {
+    out = stampImgSrc(out, paramOrName, valueAttr);
+  }
+  let result = "";
+  let cursor = 0;
+  let m;
+  refPattern.lastIndex = 0;
+  while ((m = refPattern.exec(out)) !== null) {
+    const refStart = m.index;
+    const refEnd = refStart + m[0].length;
+    if (isInsideTag(out, refStart)) {
+      result += out.slice(cursor, refEnd);
+      cursor = refEnd;
+      continue;
+    }
+    if (out[refEnd] === "." || out[refStart - 1] === ".") {
+      result += out.slice(cursor, refEnd);
+      cursor = refEnd;
+      continue;
+    }
+    const parent = findEnclosingElement(out, refStart);
+    if (!parent) {
+      result += out.slice(cursor, refEnd);
+      cursor = refEnd;
+      continue;
+    }
+    if (parent.attrs.includes("data-saastro=")) {
+      result += out.slice(cursor, refEnd);
+      cursor = refEnd;
+      continue;
+    }
+    if (parent.attrs.includes("data-saastro-field")) {
+      result += out.slice(cursor, refEnd);
+      cursor = refEnd;
+      continue;
+    }
+    const childContent = out.slice(parent.bodyStart, parent.bodyEnd);
+    const onlyChild = isOnlyMeaningfulExpression(childContent, refStart - parent.bodyStart, refEnd - parent.bodyStart);
+    if (onlyChild) {
+      const newOpen = injectAttr(parent.openTag, valueAttr);
+      const replaced = out.slice(0, parent.openStart) + newOpen + out.slice(parent.openEnd);
+      const delta = newOpen.length - parent.openTag.length;
+      result += replaced.slice(cursor, refEnd + delta);
+      cursor = refEnd + delta;
+      out = replaced;
+      refPattern.lastIndex = cursor;
+    } else {
+      const wrapped = `<span data-saastro-field=${valueAttr}>${m[0]}</span>`;
+      result += out.slice(cursor, refStart) + wrapped;
+      cursor = refEnd;
+      refPattern.lastIndex = cursor;
+    }
+  }
+  result += out.slice(cursor);
+  return result;
+}
+function stampImgSrc(template, name, valueAttr) {
+  const re = /<img\b([^<>]*?)\/?>/g;
+  let result = "";
+  let cursor = 0;
+  let m;
+  while ((m = re.exec(template)) !== null) {
+    const attrs = m[1];
+    if (/data-saastro-field/.test(attrs)) continue;
+    const srcMatch = /\bsrc\s*=\s*\{([\s\S]*?)\}/.exec(attrs);
+    if (!srcMatch) continue;
+    const srcExpr = srcMatch[1];
+    if (!new RegExp(`\\b${escapeReg(name)}\\b`).test(srcExpr)) continue;
+    const newOpen = injectAttr(m[0], valueAttr);
+    result += template.slice(cursor, m.index) + newOpen;
+    cursor = m.index + m[0].length;
+    re.lastIndex = cursor;
+  }
+  result += template.slice(cursor);
+  return result;
+}
+function escapeReg(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function injectAttr(tag, valueAttr) {
+  if (/data-saastro-field/.test(tag)) return tag;
+  const m = /^<([A-Za-z][A-Za-z0-9]*)/.exec(tag);
+  if (!m) return tag;
+  const insertAt = m[0].length;
+  return tag.slice(0, insertAt) + ` data-saastro-field=${valueAttr}` + tag.slice(insertAt);
+}
+function isInsideTag(s, pos) {
+  for (let i = pos - 1; i >= 0; i--) {
+    const ch = s[i];
+    if (ch === ">") return false;
+    if (ch === "<") return true;
+  }
+  return false;
+}
+function findEnclosingElement(s, pos) {
+  const tagRe = /<(\/?)([A-Za-z][A-Za-z0-9]*)\b([^<>]*?)(\/?)>/g;
+  const tags = [];
+  let m;
+  while ((m = tagRe.exec(s)) !== null) {
+    tags.push({
+      isClose: m[1] === "/",
+      selfClose: m[4] === "/",
+      tagName: m[2],
+      attrs: m[3],
+      start: m.index,
+      end: m.index + m[0].length
+    });
+  }
+  const stack = [];
+  let bestOpen = null;
+  let bestClose = null;
+  for (const t of tags) {
+    if (t.selfClose) continue;
+    if (t.isClose) {
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].tagName === t.tagName) {
+          const opener = stack[i];
+          stack.splice(i, stack.length - i);
+          if (opener.end <= pos && pos < t.start) {
+            if (!bestOpen || opener.end > bestOpen.end || opener.end === bestOpen.end && t.start < bestClose.start) {
+              bestOpen = opener;
+              bestClose = t;
+            }
+          }
+          break;
+        }
+      }
+    } else {
+      stack.push(t);
+    }
+  }
+  if (!bestOpen || !bestClose) return null;
+  return {
+    openStart: bestOpen.start,
+    openEnd: bestOpen.end,
+    openTag: s.slice(bestOpen.start, bestOpen.end),
+    attrs: bestOpen.attrs,
+    bodyStart: bestOpen.end,
+    bodyEnd: bestClose.start
+  };
+}
+function isOnlyMeaningfulExpression(body, relStart, relEnd) {
+  const before = body.slice(0, relStart);
+  const after = body.slice(relEnd);
+  return /^\s*$/.test(before) && /^\s*$/.test(after);
+}
+
+// src/vite/meta-tag.ts
+var STUDIO_PROTOCOL_VERSION = "2";
+var PACKAGE_VERSION = "0.1.0".length > 0 ? "0.1.0" : "0.0.0+unknown";
+var META_TAGS = [
+  `<meta name="saastro:studio-version" content="${STUDIO_PROTOCOL_VERSION}">`,
+  `<meta name="saastro:studio-package" content="${PACKAGE_VERSION}">`
+].join("\n  ");
+function injectVersionMetaTag(html) {
+  if (html.includes("saastro:studio-version")) return html;
+  return html.replace(/<head([^>]*)>/i, `<head$1>
+  ${META_TAGS}`);
+}
+
+// src/vite/index.ts
+function studioAutoWrap(opts = {}) {
+  const enabled = opts.autoWrap === true;
+  const include = opts.include ?? ((id) => id.endsWith(".astro"));
+  return {
+    name: "@saastro/studio:auto-wrap",
+    enforce: "pre",
+    transform(code, id) {
+      if (!enabled) return null;
+      if (!include(id)) return null;
+      const wrapped = transformAstroSource(code);
+      if (wrapped === code) return null;
+      const schema = extractPropsSchema(code, { componentPath: id });
+      let next = schema ? injectSchema(wrapped, schema) : wrapped;
+      if (schema) {
+        next = instrumentFields(next, schema, { componentPath: id });
+      }
+      if (next === code) return null;
+      return { code: next, map: null };
+    },
+    transformIndexHtml(html) {
+      if (!enabled) return html;
+      return injectVersionMetaTag(html);
+    }
+  };
+}
+
+export {
+  studioAutoWrap
+};
+//# sourceMappingURL=chunk-QTXHBNZQ.js.map