@estiva-app/ui 0.32.0 → 0.34.0

package/dist/registry/chunk-XVII7P6G.js

@@ -0,0 +1,595 @@
+#!/usr/bin/env node
+import {
+  SCHEMA_VERSION
+} from "./chunk-PZO4BVV3.js";
+
+// src/registry/build.ts
+import { readFileSync as readFileSync2, readdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import ts2 from "typescript";
+import { OWNED_BEHAVIOURS } from "../eslint/index.js";
+
+// src/eslint/looks-of.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve as resolvePath } from "node:path";
+import ts from "typescript";
+var PLACEMENT = [
+  /^m[xytrblse]?-/,
+  /^p[xytrblse]?-/,
+  /^(?:w|h|size|min-w|min-h|max-w|max-h)-/,
+  /^(?:hidden|block|inline|inline-block|inline-flex|inline-grid|flex|grid|contents|flow-root)$/,
+  /^(?:grow|shrink)$|^(?:flex|basis|grow|shrink|order|gap|gap-x|gap-y|space-x|space-y|col|row|grid-cols|grid-rows|grid-flow|auto-cols|auto-rows)-/,
+  /^(?:self|justify|justify-items|justify-self|items|place-content|place-items|place-self)-|^content-(?!\[)/,
+  /^(?:static|relative|absolute|fixed|sticky)$|^(?:inset|inset-x|inset-y|top|right|bottom|left|start|end|z)-/,
+  /^(?:group|peer)(?:\/[\w-]+)?$/
+];
+var bare = (token) => token.replace(/^(?:[^:\s[\]]+:)+/, "");
+var isPlacementWord = (token) => PLACEMENT.some((pattern) => pattern.test(bare(token)));
+var CLASSY = /^!?(?:[a-z0-9-]+:|\[[^\]\s]+\]:)*-?[a-z@][a-z0-9-]*(?:-\[[^\]\s]+\]|\/[\w.[\]-]+|-[\w.]+)*$|^\[[^\]\s]+\]$/;
+var words = (text) => text.split(/\s+/).filter(Boolean);
+var CLASS_FUNCTIONS = /* @__PURE__ */ new Set(["cn", "clsx", "cx", "twMerge", "classNames"]);
+var CLASS_PROP = /^(?:className|[a-z][A-Za-z]*ClassName)$/;
+function isClassList(text) {
+  const list = words(text);
+  return list.length >= 3 && list.every((w) => CLASSY.test(w)) && list.filter((w) => /[-:[]/.test(w)).length >= 2;
+}
+var CAP = 24;
+function classUnits(source, follow) {
+  const consts = /* @__PURE__ */ new Map();
+  const collect = (node) => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const) {
+      consts.set(node.name.text, node.initializer);
+    }
+    ts.forEachChild(node, collect);
+  };
+  collect(source);
+  const product = (lists) => {
+    let out = [[]];
+    for (const alternatives of lists) {
+      const next = [];
+      for (const a of out) for (const b of alternatives) if (next.length < CAP) next.push([...a, ...b]);
+      out = next;
+    }
+    return out;
+  };
+  const resolve = (node, depth = 0) => {
+    if (!node || depth > 8) return [[]];
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return [words(node.text)];
+    if (ts.isTemplateExpression(node)) return product([[words(node.head.text)], ...node.templateSpans.flatMap((span) => [resolve(span.expression, depth + 1), [words(span.literal.text)]])]);
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node)) return resolve(node.expression, depth + 1);
+    if (ts.isJsxExpression(node)) return resolve(node.expression, depth + 1);
+    if (ts.isCallExpression(node)) return ts.isIdentifier(node.expression) && CLASS_FUNCTIONS.has(node.expression.text) ? product(node.arguments.map((a) => resolve(a, depth + 1))) : [[]];
+    if (ts.isConditionalExpression(node)) return [...resolve(node.whenTrue, depth + 1), ...resolve(node.whenFalse, depth + 1)].slice(0, CAP);
+    if (ts.isBinaryExpression(node)) {
+      if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [[], ...resolve(node.right, depth + 1)];
+      if (node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) return [...resolve(node.left, depth + 1), ...resolve(node.right, depth + 1)].slice(0, CAP);
+      return [[]];
+    }
+    if (ts.isArrayLiteralExpression(node)) return product(node.elements.map((e) => resolve(e, depth + 1)));
+    if (ts.isObjectLiteralExpression(node)) return [[], node.properties.flatMap((p) => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? words(p.name.text) : [])];
+    if (ts.isIdentifier(node)) {
+      const init = consts.get(node.text) ?? follow?.(node.text);
+      return init ? resolve(init, depth + 1) : [[]];
+    }
+    if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+      let target = node.expression;
+      if (ts.isIdentifier(target)) target = consts.get(target.text) ?? follow?.(target.text);
+      while (target && (ts.isAsExpression(target) || ts.isSatisfiesExpression(target) || ts.isParenthesizedExpression(target))) target = target.expression;
+      if (!target || !ts.isObjectLiteralExpression(target)) return [[]];
+      const key = ts.isPropertyAccessExpression(node) ? node.name.text : ts.isStringLiteral(node.argumentExpression) ? node.argumentExpression.text : null;
+      return target.properties.filter((p) => ts.isPropertyAssignment(p) && (key === null || !!p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === key)).flatMap((p) => resolve(p.initializer, depth + 1)).slice(0, CAP);
+    }
+    return [[]];
+  };
+  const units = [];
+  const seen = /* @__PURE__ */ new Set();
+  const sharedAt = (node) => {
+    for (let at = node; at; at = at.parent) {
+      if (ts.isVariableDeclaration(at)) return ts.isIdentifier(at.name) && /_CLASSES$/.test(at.name.text) && !!at.parent?.parent && ts.isVariableStatement(at.parent.parent) && !!at.parent.parent.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    }
+    return false;
+  };
+  const lineStart = (node) => {
+    const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line;
+    let at = node;
+    while (at.parent && !ts.isSourceFile(at.parent) && source.getLineAndCharacterOfPosition(at.parent.getStart(source)).line === line) at = at.parent;
+    return at.getStart(source);
+  };
+  const add = (tokens, node, via, anchor = via === "literal" ? lineStart(node) : node.getStart(source)) => {
+    const list = [...new Set(tokens.filter((t) => CLASSY.test(t)))];
+    const look = list.filter((t) => !isPlacementWord(t));
+    if (look.length === 0) return;
+    const key = `${via}:${node.getStart(source)}:${[...list].sort().join(" ")}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    units.push({ tokens: list, look, start: node.getStart(source), end: node.getEnd(), via, anchor, shared: via === "literal" && sharedAt(node) });
+  };
+  const visit = (node) => {
+    if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && CLASS_PROP.test(node.name.text) && node.initializer) {
+      const element = node.parent.parent;
+      for (const alternative of resolve(node.initializer)) add(alternative, node, "attribute", element.getStart(source));
+    }
+    if ((ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) && isClassList(node.text)) add(words(node.text), node, "literal");
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return units;
+}
+function componentsOf(source) {
+  const found = /* @__PURE__ */ new Map();
+  const fn = (node) => {
+    let current = node;
+    while (current && ts.isCallExpression(current) && current.arguments.length) current = current.arguments[0];
+    return current && (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) ? current : void 0;
+  };
+  for (const statement of source.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && /^[A-Z]/.test(statement.name.text)) found.set(statement.name.text, { start: statement.getStart(source), end: statement.getEnd() });
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        const body = fn(declaration.initializer);
+        if (ts.isIdentifier(declaration.name) && /^[A-Z]/.test(declaration.name.text) && body) found.set(declaration.name.text, { start: body.getStart(source), end: body.getEnd() });
+      }
+    }
+  }
+  return found;
+}
+var MIN_LOOK_WORDS = 4;
+function looksOf(source, names) {
+  const components = componentsOf(source);
+  const units = classUnits(source, importedConstants(source)).filter((u) => u.look.length >= MIN_LOOK_WORDS);
+  const inside = (u, r) => u.start >= r.start && u.start < r.end;
+  const out = /* @__PURE__ */ new Map();
+  for (const name of names ?? components.keys()) {
+    const range = components.get(name);
+    const mine = units.filter((u) => (range ? inside(u, range) : false) || ![...components.values()].some((r) => inside(u, r)));
+    out.set(name, [...new Set(mine.map((u) => u.look.join(" ")))]);
+  }
+  return out;
+}
+function parseForLooks(fileName, text) {
+  return ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+}
+function importTarget(fromFile, specifier) {
+  let base;
+  if (specifier.startsWith(".")) base = resolvePath(dirname(fromFile), specifier);
+  else if (specifier.startsWith("@/")) {
+    let dir = dirname(resolvePath(fromFile));
+    while (!existsSync(join(dir, "package.json")) && dirname(dir) !== dir) dir = dirname(dir);
+    base = join(dir, "src", specifier.slice(2));
+  } else return null;
+  for (const candidate of [`${base}.ts`, `${base}.tsx`, join(base, "index.ts")]) if (existsSync(candidate)) return candidate;
+  return null;
+}
+var constantsCache = /* @__PURE__ */ new Map();
+function constantsOf(file) {
+  const cached = constantsCache.get(file);
+  if (cached) return cached;
+  const found = /* @__PURE__ */ new Map();
+  const source = parseForLooks(file, readFileSync(file, "utf8"));
+  for (const statement of source.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const d of statement.declarationList.declarations) if (ts.isIdentifier(d.name) && d.initializer) found.set(d.name.text, d.initializer);
+  }
+  constantsCache.set(file, found);
+  return found;
+}
+function importedConstants(source) {
+  const imported = /* @__PURE__ */ new Map();
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings)) continue;
+    const target = importTarget(source.fileName, statement.moduleSpecifier.text);
+    if (!target) continue;
+    for (const element of bindings.elements) {
+      const local = element.name.text;
+      if (/_CLASSES$/.test(element.propertyName?.text ?? local)) imported.set(local, { file: target, name: element.propertyName?.text ?? local });
+    }
+  }
+  return (name) => {
+    const from = imported.get(name);
+    if (!from) return void 0;
+    try {
+      return constantsOf(from.file).get(from.name);
+    } catch {
+      return void 0;
+    }
+  };
+}
+
+// src/registry/build.ts
+var PACKAGE_IMPORT = "@estiva-app/ui";
+function sanitize(name) {
+  return name.toLowerCase().replace(/[ ’–—―′¿'`~!@#$%^&*()_|+\-=?;:'",.<>{}[\]\\/]/g, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function storyNameFromExport(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-zA-Z])([0-9])/g, "$1 $2").replace(/([0-9])([a-zA-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+}
+var toId = (title, name) => `${sanitize(title)}--${sanitize(storyNameFromExport(name))}`;
+function readIndexExports(source) {
+  const file = ts2.createSourceFile("index.ts", source, ts2.ScriptTarget.Latest, true);
+  const found = [];
+  for (const statement of file.statements) {
+    if (!ts2.isExportDeclaration(statement)) continue;
+    const from = statement.moduleSpecifier;
+    const clause = statement.exportClause;
+    if (!from || !ts2.isStringLiteral(from) || !clause || !ts2.isNamedExports(clause)) continue;
+    for (const element of clause.elements) {
+      found.push({ name: element.name.text, module: from.text.replace(/^\.\//, ""), isType: statement.isTypeOnly || element.isTypeOnly });
+    }
+  }
+  return found;
+}
+function docAbove(source, node, headerPos = null) {
+  const ranges = ts2.getLeadingCommentRanges(source, node.getFullStart()) ?? [];
+  const jsdoc = ranges.filter((range) => source.slice(range.pos, range.pos + 3) === "/**").pop();
+  if (!jsdoc) return "";
+  if (headerPos !== null && jsdoc.pos === headerPos) return "";
+  const between = source.slice(jsdoc.end, node.getStart());
+  if (between.replace(/\/\/[^\n]*/g, "").trim() !== "") return "";
+  return source.slice(jsdoc.pos, jsdoc.end).split(/\r?\n/).map((line) => line.trim().replace(/^\/\*\*/, "").replace(/\*\/$/, "").replace(/^\*/, "").trim()).join("\n").trim();
+}
+function firstSentence(prose) {
+  const flat = prose.split(/\n\s*\n/)[0].split("\n").filter((line2) => !line2.trim().startsWith("@")).join(" ").replace(/\*\*/g, "").replace(/\s+/g, " ").trim();
+  const parts = flat.split(/(?<=[.!?])\s+(?=[A-Z`'"‘“])/);
+  let line = parts[0] ?? "";
+  if (line.length < 40 && parts[1]) line = `${line} ${parts[1]}`;
+  return line.trim();
+}
+function pageOpening(mdx) {
+  const lines = mdx.split(/\r?\n/);
+  const heading = lines.findIndex((line) => /^#\s+\S/.test(line));
+  if (heading < 0) return "";
+  const paragraph = [];
+  for (const line of lines.slice(heading + 1)) {
+    const text = line.trim();
+    if (text === "") {
+      if (paragraph.length) break;
+      continue;
+    }
+    if (text.startsWith("<") || text.startsWith("#")) break;
+    paragraph.push(text);
+  }
+  return paragraph.join(" ");
+}
+function propName(member) {
+  if (!member.name) return null;
+  if (ts2.isIdentifier(member.name) || ts2.isStringLiteral(member.name)) return member.name.text;
+  return null;
+}
+function literalUnion(type, aliases, seen = /* @__PURE__ */ new Set()) {
+  if (!type) return null;
+  if (ts2.isTypeReferenceNode(type) && ts2.isIdentifier(type.typeName)) {
+    const name = type.typeName.text;
+    if (seen.has(name)) return null;
+    seen.add(name);
+    const alias = aliases.get(name);
+    return alias ? literalUnion(alias, aliases, seen) : null;
+  }
+  if (ts2.isLiteralTypeNode(type) && ts2.isStringLiteral(type.literal)) return [type.literal.text];
+  if (!ts2.isUnionTypeNode(type)) return null;
+  const values = [];
+  for (const member of type.types) {
+    if (member.kind === ts2.SyntaxKind.UndefinedKeyword || member.kind === ts2.SyntaxKind.NullKeyword) continue;
+    const inner = literalUnion(member, aliases, seen);
+    if (!inner) return null;
+    values.push(...inner);
+  }
+  return values.length > 1 ? values : null;
+}
+function readModule(source, sibling = () => void 0, { lendFirstComment = true } = {}) {
+  const file = ts2.createSourceFile("module.tsx", source, ts2.ScriptTarget.Latest, true);
+  const declarations = /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ new Map();
+  const shapes = /* @__PURE__ */ new Map();
+  const bases = /* @__PURE__ */ new Map();
+  const importedFrom = /* @__PURE__ */ new Map();
+  const propsTypeOf = (parameters) => parameters[0]?.type;
+  const propsOfInitializer = (initializer) => {
+    if (!initializer) return void 0;
+    if (ts2.isArrowFunction(initializer) || ts2.isFunctionExpression(initializer)) return propsTypeOf(initializer.parameters);
+    if (ts2.isCallExpression(initializer)) {
+      const callee = ts2.isPropertyAccessExpression(initializer.expression) ? initializer.expression.name.text : ts2.isIdentifier(initializer.expression) ? initializer.expression.text : "";
+      if (callee === "forwardRef" && initializer.typeArguments?.[1]) return initializer.typeArguments[1];
+      const wrapped = initializer.arguments.find((argument) => ts2.isArrowFunction(argument) || ts2.isFunctionExpression(argument));
+      if (wrapped) return propsTypeOf(wrapped.parameters);
+    }
+    return void 0;
+  };
+  const propsOfAnnotation = (type) => {
+    if (!type || !ts2.isTypeReferenceNode(type)) return void 0;
+    const named = ts2.isIdentifier(type.typeName) ? type.typeName.text : type.typeName.right.text;
+    return named === "FC" || named === "FunctionComponent" ? type.typeArguments?.[0] : void 0;
+  };
+  const opening = file.statements.find((statement) => !ts2.isImportDeclaration(statement));
+  const headerPos = opening ? (ts2.getLeadingCommentRanges(source, opening.getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**")?.pos ?? null : null;
+  const topPos = file.statements[0] ? (ts2.getLeadingCommentRanges(source, file.statements[0].getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**")?.pos ?? null : null;
+  const aboveImports = !!file.statements[0] && ts2.isImportDeclaration(file.statements[0]);
+  const refused = lendFirstComment ? topPos ?? headerPos : aboveImports ? topPos : null;
+  for (const statement of file.statements) {
+    if (ts2.isImportDeclaration(statement) && ts2.isStringLiteral(statement.moduleSpecifier)) {
+      const bindings = statement.importClause?.namedBindings;
+      if (bindings && ts2.isNamedImports(bindings)) {
+        for (const element of bindings.elements) importedFrom.set(element.name.text, { specifier: statement.moduleSpecifier.text, imported: (element.propertyName ?? element.name).text });
+      }
+    }
+    if (ts2.isExportDeclaration(statement) && statement.moduleSpecifier && ts2.isStringLiteral(statement.moduleSpecifier) && statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) importedFrom.set(element.name.text, { specifier: statement.moduleSpecifier.text, imported: (element.propertyName ?? element.name).text });
+    }
+    if (ts2.isTypeAliasDeclaration(statement)) aliases.set(statement.name.text, statement.type);
+    if (ts2.isInterfaceDeclaration(statement)) {
+      shapes.set(statement.name.text, [...statement.members]);
+      const extended = (statement.heritageClauses ?? []).flatMap((clause) => [...clause.types]);
+      if (extended.length) bases.set(statement.name.text, extended);
+    }
+    if (ts2.isTypeAliasDeclaration(statement) && ts2.isTypeLiteralNode(statement.type)) shapes.set(statement.name.text, [...statement.type.members]);
+    if (ts2.isClassDeclaration(statement)) {
+      const base = (statement.heritageClauses ?? []).find((clause) => clause.token === ts2.SyntaxKind.ExtendsKeyword)?.types[0];
+      const name = statement.name?.text ?? (ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword) ? "default" : null);
+      if (name) declarations.set(name, { doc: docAbove(source, statement, refused), deprecated: false, propsType: base?.typeArguments?.[0] });
+      continue;
+    }
+    if (ts2.isExportAssignment(statement) && !statement.isExportEquals && !ts2.isIdentifier(statement.expression)) {
+      declarations.set("default", { doc: docAbove(source, statement, refused), deprecated: false, propsType: propsOfInitializer(statement.expression) });
+      continue;
+    }
+    if (ts2.isFunctionDeclaration(statement) && !statement.name && ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword)) {
+      declarations.set("default", { doc: docAbove(source, statement, refused), deprecated: false, propsType: propsTypeOf(statement.parameters) });
+      continue;
+    }
+    if (!ts2.isFunctionDeclaration(statement) && !ts2.isVariableStatement(statement)) continue;
+    const doc = docAbove(source, statement, refused);
+    const deprecated = /(^|\n)@deprecated\b/.test(doc) || /\*\s*@deprecated\b/.test(source.slice(Math.max(0, statement.getFullStart()), statement.getStart()));
+    if (ts2.isFunctionDeclaration(statement) && statement.name) {
+      const held = declarations.get(statement.name.text);
+      if (held) {
+        if (!held.doc && doc) held.doc = doc;
+        continue;
+      }
+      declarations.set(statement.name.text, { doc, deprecated, propsType: propsTypeOf(statement.parameters) });
+      continue;
+    }
+    if (ts2.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts2.isIdentifier(declaration.name)) continue;
+        declarations.set(declaration.name.text, { doc, deprecated, propsType: propsOfInitializer(declaration.initializer) ?? propsOfAnnotation(declaration.type) });
+      }
+    }
+  }
+  const EMPTY = { props: [], variants: [] };
+  const keysOf = (type) => {
+    if (!type) return null;
+    if (ts2.isLiteralTypeNode(type) && ts2.isStringLiteral(type.literal)) return [type.literal.text];
+    if (!ts2.isUnionTypeNode(type)) return null;
+    const keys = [];
+    for (const member of type.types) {
+      if (!ts2.isLiteralTypeNode(member) || !ts2.isStringLiteral(member.literal)) return null;
+      keys.push(member.literal.text);
+    }
+    return keys;
+  };
+  const narrow = (resolved, how, keys) => {
+    if (!keys) return resolved;
+    const named = new Set(keys);
+    const keep = (name) => how === "Omit" ? !named.has(name) : named.has(name);
+    return { props: resolved.props.filter((prop) => keep(prop.name)), variants: resolved.variants.filter((variant) => keep(variant.prop)) };
+  };
+  const merge = (parts) => {
+    const props = [];
+    const variants = [];
+    const seenProp = /* @__PURE__ */ new Set();
+    const seenVariant = /* @__PURE__ */ new Set();
+    for (const part of parts) {
+      for (const prop of part.props) if (!seenProp.has(prop.name)) seenProp.add(prop.name), props.push(prop);
+      for (const variant of part.variants) if (!seenVariant.has(variant.prop)) seenVariant.add(variant.prop), variants.push(variant);
+    }
+    return { props, variants };
+  };
+  const takes = (type, values) => {
+    if (values) return values.join(" | ");
+    if (!type) return "anything";
+    const written = type.getText(file).replace(/\s+/g, " ").trim();
+    if (written === "boolean") return "true/false";
+    if (written === "number") return "number";
+    if (written === "string") return "text";
+    if (/^React(Node|Element)\b/.test(written)) return "anything";
+    if (written.includes("=>")) return "a handler";
+    return written.length > 60 ? `${written.slice(0, 57)}\u2026` : written;
+  };
+  const fromMembers = (members) => {
+    const props = [];
+    const variants = [];
+    for (const member of members) {
+      const name = propName(member);
+      if (name === null || !ts2.isPropertySignature(member)) continue;
+      const values = literalUnion(member.type, aliases);
+      const note = firstSentence(docAbove(source, member));
+      props.push({ name, takes: takes(member.type, values), required: !member.questionToken, note: note || null });
+      if (values) variants.push({ prop: name, values });
+    }
+    return { props, variants };
+  };
+  const resolveNode = (type, seen) => {
+    if (!type || seen.size > 12) return EMPTY;
+    if (ts2.isTypeLiteralNode(type)) return fromMembers(type.members);
+    if (ts2.isIntersectionTypeNode(type)) return merge(type.types.map((side) => resolveNode(side, seen)));
+    if (ts2.isTypeReferenceNode(type) && ts2.isIdentifier(type.typeName)) {
+      const named = type.typeName.text;
+      if (named === "Omit" || named === "Pick") {
+        return narrow(resolveNode(type.typeArguments?.[0], seen), named, keysOf(type.typeArguments?.[1]));
+      }
+      return resolveName(named, seen);
+    }
+    return EMPTY;
+  };
+  const resolveBase = (base, seen) => {
+    if (!ts2.isIdentifier(base.expression)) return EMPTY;
+    const named = base.expression.text;
+    if (named === "Omit" || named === "Pick") {
+      return narrow(resolveNode(base.typeArguments?.[0], seen), named, keysOf(base.typeArguments?.[1]));
+    }
+    return resolveName(named, seen);
+  };
+  function resolveName(name, seen) {
+    if (seen.has(name) || seen.size > 12) return EMPTY;
+    seen.add(name);
+    const own = shapes.get(name);
+    if (own) {
+      const inherited = (bases.get(name) ?? []).map((base) => resolveBase(base, seen));
+      return merge([fromMembers(own), ...inherited]);
+    }
+    const alias = aliases.get(name);
+    if (alias) return resolveNode(alias, seen);
+    const from = importedFrom.get(name);
+    return (from ? sibling(from.specifier, from.imported) : void 0) ?? EMPTY;
+  }
+  const resolve = (propsType) => resolveNode(propsType, /* @__PURE__ */ new Set());
+  const jsdocAt = (node) => node ? (ts2.getLeadingCommentRanges(source, node.getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**") : void 0;
+  const headerRange = jsdocAt(file.statements[0]) ?? jsdocAt(opening);
+  return { declarations, headerDoc: headerRange ? headerComment(source, headerRange) : "", resolve, resolveName: (name) => resolveName(name, /* @__PURE__ */ new Set()) };
+}
+function headerComment(source, range) {
+  return source.slice(range.pos, range.end).split(/\r?\n/).map((line) => line.trim().replace(/^\/\*\*/, "").replace(/\*\/$/, "").replace(/^\*/, "").trim()).join("\n").trim();
+}
+function readStories(source) {
+  const file = ts2.createSourceFile("x.stories.tsx", source, ts2.ScriptTarget.Latest, true);
+  let title = null;
+  const stories = [];
+  for (const statement of file.statements) {
+    if (ts2.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts2.isIdentifier(declaration.name)) continue;
+        const initializer = declaration.initializer;
+        const object = initializer && ts2.isSatisfiesExpression(initializer) ? initializer.expression : initializer;
+        if (declaration.name.text === "meta" && object && ts2.isObjectLiteralExpression(object)) {
+          for (const property of object.properties) {
+            if (ts2.isPropertyAssignment(property) && ts2.isIdentifier(property.name) && property.name.text === "title" && ts2.isStringLiteral(property.initializer)) {
+              title = property.initializer.text;
+            }
+          }
+        }
+        const exported = ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+        if (exported && declaration.name.text !== "meta") stories.push(declaration.name.text);
+      }
+    }
+  }
+  return { title, stories };
+}
+var isAllCaps = (name) => /^[A-Z0-9_]+$/.test(name);
+function kindOf(name) {
+  if (/^use[A-Z]/.test(name)) return "hook";
+  return /^[A-Z]/.test(name) && !isAllCaps(name) ? "component" : "helper";
+}
+function behavioursOf(name) {
+  return OWNED_BEHAVIOURS.filter((owned) => owned.owners.includes(name)).map((owned) => ({ id: owned.id, behaviour: owned.behaviour }));
+}
+function buildRegistry({ root = process.cwd(), repo = "estiva-ui" } = {}) {
+  const src = join2(root, "src");
+  const manifest = JSON.parse(readFileSync2(join2(root, "package.json"), "utf8"));
+  const files = new Set(readdirSync(src));
+  const exported = readIndexExports(readFileSync2(join2(src, "index.ts"), "utf8"));
+  const values = exported.filter((entry) => !entry.isType);
+  const modules = /* @__PURE__ */ new Map();
+  const moduleOf = (name) => {
+    const held = modules.get(name);
+    if (held) return held;
+    const file = [".tsx", ".ts"].map((extension) => `${name}${extension}`).find((candidate) => files.has(candidate));
+    if (!file) throw new Error(`src/index.ts exports from './${name}', which is not a file in src/`);
+    const read = { ...readModule(readFileSync2(join2(src, file), "utf8"), (specifier, typeName) => specifier.startsWith("./") ? moduleOf(specifier.slice(2)).resolveName(typeName) : void 0), file: `src/${file}` };
+    modules.set(name, read);
+    return read;
+  };
+  const problems = [];
+  const entries = [];
+  const looksCache = /* @__PURE__ */ new Map();
+  const looksFor = (file, name) => {
+    if (!looksCache.has(file)) looksCache.set(file, parseForLooks(join2(src, file.replace(/^src\//, "")), readFileSync2(join2(src, file.replace(/^src\//, "")), "utf8")));
+    return looksOf(looksCache.get(file), [name]).get(name) ?? [];
+  };
+  for (const value of values) {
+    const module = moduleOf(value.module);
+    const declared = module.declarations.get(value.name);
+    if (!declared) {
+      problems.push(`${value.name} is exported from './${value.module}' but is not declared there`);
+      continue;
+    }
+    const pageFile = files.has(`${value.name}.mdx`) ? `src/${value.name}.mdx` : null;
+    const fromPage = pageFile ? firstSentence(pageOpening(readFileSync2(join2(root, pageFile), "utf8"))) : "";
+    const fromComment = firstSentence(declared.doc);
+    const purpose = fromPage || fromComment;
+    if (!purpose) {
+      problems.push(`${value.name} has no purpose: no opening paragraph on its page, and no doc comment above it in ${module.file}`);
+      continue;
+    }
+    const storiesFile = files.has(`${value.name}.stories.tsx`) ? `${value.name}.stories.tsx` : files.has(`${value.module}.stories.tsx`) ? `${value.module}.stories.tsx` : null;
+    const stories = storiesFile ? readStories(readFileSync2(join2(src, storiesFile), "utf8")) : { title: null, stories: [] };
+    const title = stories.title;
+    const story = stories.stories.includes(value.name) ? value.name : stories.stories[0];
+    const shape = module.resolve(declared.propsType);
+    entries.push({
+      name: value.name,
+      repo,
+      kind: kindOf(value.name),
+      importPath: PACKAGE_IMPORT,
+      sourceFile: module.file,
+      purpose,
+      purposeFrom: fromPage ? "page" : "comment",
+      props: shape.props,
+      variants: shape.variants,
+      ownsBehaviours: behavioursOf(value.name),
+      status: declared.deprecated ? "deprecated" : "stable",
+      migrationStage: null,
+      docsId: title ? `${sanitize(title)}--docs` : null,
+      storyId: title && story ? toId(title, story) : null,
+      docPage: pageFile,
+      app: null,
+      looks: kindOf(value.name) === "component" ? looksFor(module.file, value.name) : []
+    });
+  }
+  if (problems.length) throw new Error(`the registry cannot be built:
+  ${problems.join("\n  ")}`);
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    builtFrom: {
+      kind: "package",
+      repo,
+      package: manifest.name,
+      packageVersion: manifest.version,
+      exports: values.length,
+      typeExports: exported.length - values.length,
+      files: null
+    },
+    storybook: {
+      docsPath: "/?path=/docs/{docsId}",
+      storyPath: "/?path=/story/{storyId}",
+      devUrl: "http://localhost:6008"
+    },
+    entries,
+    // Nothing is excluded: every value export is an entry, helpers and the one
+    // hook included, each marked by `kind`. The field stays because the count
+    // has to reconcile out loud — see validateRegistry.
+    excluded: [],
+    filesWithoutParts: []
+  };
+}
+function serializeRegistry(registry) {
+  return `${JSON.stringify(registry, null, 2)}
+`;
+}
+
+export {
+  looksOf,
+  parseForLooks,
+  PACKAGE_IMPORT,
+  sanitize,
+  toId,
+  readIndexExports,
+  firstSentence,
+  pageOpening,
+  readModule,
+  readStories,
+  buildRegistry,
+  serializeRegistry
+};
+//# sourceMappingURL=chunk-XVII7P6G.js.map