@estiva-app/ui 0.33.0 → 0.35.0

package/dist/eslint/index.js

@@ -224,7 +224,7 @@ var PART_LOOK_PROPS = {
   Reaction: ["pressed"],
   ReactionPicker: ["surface"],
   SectionHeader: ["hover"],
-  SectionLabel: ["tone"],
+  SectionLabel: ["tone", "truncate"],
   Select: ["size"],
   Tabs: ["size"],
   TextInput: ["size"],
@@ -547,12 +547,12 @@ function classesOf(value, scopeOf, asMap = false, seen = /* @__PURE__ */ new Set
   if (!value || seen.has(value) || seen.size > 200) return [];
   seen.add(value);
   const read = (node, map = false) => classesOf(node, scopeOf, map, seen);
-  const words = (text) => typeof text === "string" ? text.split(/\s+/).filter(Boolean) : [];
+  const words2 = (text) => typeof text === "string" ? text.split(/\s+/).filter(Boolean) : [];
   switch (value.type) {
     case "Literal":
-      return words(value.value);
+      return words2(value.value);
     case "TemplateLiteral":
-      return [...children(value, "quasis").flatMap((quasi) => words((quasi?.value).cooked)), ...children(value, "expressions").flatMap((e) => read(e))];
+      return [...children(value, "quasis").flatMap((quasi) => words2((quasi?.value).cooked)), ...children(value, "expressions").flatMap((e) => read(e))];
     case "JSXExpressionContainer":
     case "TSAsExpression":
     case "TSSatisfiesExpression":
@@ -570,7 +570,7 @@ function classesOf(value, scopeOf, asMap = false, seen = /* @__PURE__ */ new Set
     case "ObjectExpression":
       return children(value, "properties").flatMap((property) => {
         if (property?.type !== "Property") return [];
-        return asMap ? read(child(property, "value"), true) : property.computed ? [] : words(nameOf(child(property, "key")));
+        return asMap ? read(child(property, "value"), true) : property.computed ? [] : words2(nameOf(child(property, "key")));
       });
     case "CallExpression": {
       const callee = child(value, "callee");
@@ -852,8 +852,8 @@ var noHandmadeEmptyState = {
         const opening = child2(element, "openingElement");
         const tag = tagName(element);
         if (tag && /^[a-z]/.test(tag)) {
-          const words = onlyWords(element);
-          if (!words || words.length > SHORT) return;
+          const words2 = onlyWords(element);
+          if (!words2 || words2.length > SHORT) return;
           if (!standsInForAList(element)) return;
           if (isEscaped(context, opening)) return;
           context.report({ loc: opening.loc, messageId: "handmade" });
@@ -984,10 +984,381 @@ var noHandmadeHeader = {
   }
 };
 
+// src/eslint/no-copied-look.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync, statSync as statSync3 } from "node:fs";
+import { dirname as dirname3, join as join3, relative, resolve as resolve2 } from "node:path";
+
+// src/eslint/looks-of.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, resolve as resolvePath } from "node:path";
+import ts from "typescript";
+var PLACEMENT2 = [
+  /^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) => PLACEMENT2.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_FUNCTIONS2 = /* @__PURE__ */ new Set(["cn", "clsx", "cx", "twMerge", "classNames"]);
+var CLASS_PROP2 = /^(?: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 resolve3 = (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) => [resolve3(span.expression, depth + 1), [words(span.literal.text)]])]);
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node)) return resolve3(node.expression, depth + 1);
+    if (ts.isJsxExpression(node)) return resolve3(node.expression, depth + 1);
+    if (ts.isCallExpression(node)) return ts.isIdentifier(node.expression) && CLASS_FUNCTIONS2.has(node.expression.text) ? product(node.arguments.map((a) => resolve3(a, depth + 1))) : [[]];
+    if (ts.isConditionalExpression(node)) return [...resolve3(node.whenTrue, depth + 1), ...resolve3(node.whenFalse, depth + 1)].slice(0, CAP);
+    if (ts.isBinaryExpression(node)) {
+      if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [[], ...resolve3(node.right, depth + 1)];
+      if (node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) return [...resolve3(node.left, depth + 1), ...resolve3(node.right, depth + 1)].slice(0, CAP);
+      return [[]];
+    }
+    if (ts.isArrayLiteralExpression(node)) return product(node.elements.map((e) => resolve3(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 ? resolve3(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) => resolve3(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_PROP2.test(node.name.text) && node.initializer) {
+      const element = node.parent.parent;
+      for (const alternative of resolve3(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 statement2 of source.statements) {
+    if (ts.isFunctionDeclaration(statement2) && statement2.name && /^[A-Z]/.test(statement2.name.text)) found.set(statement2.name.text, { start: statement2.getStart(source), end: statement2.getEnd() });
+    if (ts.isVariableStatement(statement2)) {
+      for (const declaration of statement2.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(fileName2, text) {
+  return ts.createSourceFile(fileName2, text, ts.ScriptTarget.Latest, true, fileName2.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+}
+var MIN_SHARED = 4;
+var MIN_COVER = 0.8;
+function copies(list, look) {
+  const mine = new Set(list);
+  const shared = look.filter((word) => mine.has(word));
+  if (shared.length < MIN_SHARED) return null;
+  return shared.length / Math.min(list.length, look.length) >= MIN_COVER ? shared : null;
+}
+function importTarget(fromFile, specifier) {
+  let base;
+  if (specifier.startsWith(".")) base = resolvePath(dirname2(fromFile), specifier);
+  else if (specifier.startsWith("@/")) {
+    let dir = dirname2(resolvePath(fromFile));
+    while (!existsSync3(join2(dir, "package.json")) && dirname2(dir) !== dir) dir = dirname2(dir);
+    base = join2(dir, "src", specifier.slice(2));
+  } else return null;
+  for (const candidate of [`${base}.ts`, `${base}.tsx`, join2(base, "index.ts")]) if (existsSync3(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, readFileSync2(file, "utf8"));
+  for (const statement2 of source.statements) {
+    if (!ts.isVariableStatement(statement2)) continue;
+    for (const d of statement2.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 statement2 of source.statements) {
+    if (!ts.isImportDeclaration(statement2) || !ts.isStringLiteral(statement2.moduleSpecifier)) continue;
+    const bindings = statement2.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings)) continue;
+    const target = importTarget(source.fileName, statement2.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;
+    }
+  };
+}
+function sharedLooksOf(source) {
+  const out = /* @__PURE__ */ new Map();
+  const lookWords = (text) => words(text).filter((w) => CLASSY.test(w) && !isPlacementWord(w));
+  for (const statement2 of source.statements) {
+    if (!ts.isVariableStatement(statement2) || !statement2.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) continue;
+    for (const d of statement2.declarationList.declarations) {
+      if (!ts.isIdentifier(d.name) || !/_CLASSES$/.test(d.name.text) || !d.initializer) continue;
+      let init = d.initializer;
+      while (ts.isAsExpression(init) || ts.isSatisfiesExpression(init) || ts.isParenthesizedExpression(init)) init = init.expression;
+      if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+        const look = lookWords(init.text);
+        if (look.length >= MIN_LOOK_WORDS) out.set(d.name.text, [look.join(" ")]);
+      } else if (ts.isObjectLiteralExpression(init)) {
+        for (const p of init.properties) {
+          if (!ts.isPropertyAssignment(p) || !p.name || !(ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) continue;
+          if (!(ts.isStringLiteral(p.initializer) || ts.isNoSubstitutionTemplateLiteral(p.initializer))) continue;
+          const look = lookWords(p.initializer.text);
+          if (look.length >= MIN_LOOK_WORDS) out.set(`${d.name.text}.${p.name.text}`, [look.join(" ")]);
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// src/eslint/no-copied-look.ts
+var packageDirCache2 = /* @__PURE__ */ new Map();
+function packageDirOf2(file) {
+  const start = dirname3(resolve2(file));
+  if (packageDirCache2.has(start)) return packageDirCache2.get(start) ?? null;
+  let dir = start;
+  for (; ; ) {
+    if (existsSync4(join3(dir, "package.json"))) break;
+    const up = dirname3(dir);
+    if (up === dir) {
+      dir = "";
+      break;
+    }
+    dir = up;
+  }
+  packageDirCache2.set(start, dir || null);
+  return dir || null;
+}
+var PACKAGE2 = "@estiva-app/ui";
+var nameOf3 = (dir) => {
+  try {
+    return JSON.parse(readFileSync3(join3(dir, "package.json"), "utf8")).name;
+  } catch {
+    return void 0;
+  }
+};
+var shippedCache = /* @__PURE__ */ new Map();
+function shippedLooks(appDir) {
+  for (let dir = appDir; ; dir = dirname3(dir)) {
+    const file = join3(dir, "node_modules", PACKAGE2, "registry.json");
+    if (existsSync4(file)) {
+      const mtime = statSync3(file).mtimeMs;
+      const cached = shippedCache.get(file);
+      if (cached && cached.mtime === mtime) return cached.looks;
+      let looks = [];
+      try {
+        const registry = JSON.parse(readFileSync3(file, "utf8"));
+        looks = registry.entries.flatMap((e) => (e.looks ?? []).map((l) => ({ part: e.name, file: e.sourceFile, look: l.split(" "), from: "package" })));
+      } catch {
+      }
+      shippedCache.set(file, { mtime, looks });
+      return looks;
+    }
+    if (dirname3(dir) === dir) return [];
+  }
+}
+function exportedNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  const text = source.text;
+  for (const m of text.matchAll(/export\s+(?:default\s+)?(?:function|const)\s+([A-Z]\w*)/g)) names.add(m[1]);
+  for (const m of text.matchAll(/export\s*\{([^}]*)\}/g)) for (const part of m[1].split(",")) {
+    const name = part.trim().split(/\s+as\s+/).pop();
+    if (name && /^[A-Z]/.test(name)) names.add(name);
+  }
+  return names;
+}
+var ownCache = /* @__PURE__ */ new Map();
+function ownLooks(repoDir) {
+  const out = [];
+  const walk2 = (dir) => {
+    let names = [];
+    try {
+      names = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (name === "node_modules" || name === "dist") continue;
+      const path = join3(dir, name);
+      if (statSync3(path).isDirectory()) walk2(path);
+      else if (/\.tsx?$/.test(name) && !/\.(?:stories|test)\.tsx?$/.test(name) && !name.endsWith(".d.ts")) {
+        const mtime = statSync3(path).mtimeMs;
+        let cached = ownCache.get(path);
+        if (!cached || cached.mtime !== mtime) {
+          const text = readFileSync3(path, "utf8");
+          const source = parseForLooks(path, text);
+          const exported = name.endsWith(".tsx") ? [...componentsOf(source).keys()].filter((n) => exportedNames(source).has(n)) : [];
+          const file = relative(repoDir, path).replace(/\\/g, "/");
+          const looks = [...looksOf(source, exported)].flatMap(([part, lists]) => lists.map((l) => ({ part, file, look: l.split(" "), from: "own" })));
+          if (text.includes("_CLASSES")) for (const [part, lists] of sharedLooksOf(source)) for (const l of lists) looks.push({ part, file, look: l.split(" "), from: "shared" });
+          cached = { mtime, looks };
+          ownCache.set(path, cached);
+        }
+        out.push(...cached.looks);
+      }
+    }
+  };
+  walk2(join3(repoDir, "src"));
+  return out;
+}
+var noCopiedLook = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "A part's look typed again by hand, where the part (or a shared look) should be used" },
+    schema: [],
+    messages: {
+      usePart: "This class list is `{{part}}`'s look, typed again ({{count}} words: {{words}}). Use `{{part}}` from {{from}}: a copy looks right today and stays behind the day `{{part}}` changes.",
+      shareIt: "This look is also written in `{{part}}` ({{file}}): {{words}}. Write it once in src/looks.ts and use it in both, so the two cannot drift apart.",
+      useShared: "This class list is `{{part}}` ({{file}}), typed again: {{words}}. Use `{{part}}`: a look written once cannot drift apart.",
+      ...ESCAPE_MESSAGES
+    }
+  },
+  create(context) {
+    const file = context.filename;
+    const repoDir = packageDirOf2(file);
+    if (!repoDir) return {};
+    const inPackage = nameOf3(repoDir) === PACKAGE2;
+    return {
+      Program() {
+        const here = relative(repoDir, file).replace(/\\/g, "/");
+        const source = parseForLooks(file, context.sourceCode.text);
+        const declared = new Set(componentsOf(source).keys());
+        const looks = [...inPackage ? [] : shippedLooks(repoDir), ...ownLooks(repoDir)].filter((l) => l.file !== here && !declared.has(l.part));
+        if (!looks.length) return;
+        const units = classUnits(source);
+        const within = (u) => units.some((o) => o !== u && o.via === "attribute" && u.via === "literal" && u.start >= o.start && u.end <= o.end);
+        const reported = /* @__PURE__ */ new Set();
+        for (const unit of units) {
+          if (within(unit) || reported.has(unit.start)) continue;
+          let best = null;
+          for (const look of looks) {
+            if (unit.shared && look.from !== "package") continue;
+            const shared = copies(unit.look, look.look);
+            if (shared && (!best || shared.length > best.shared.length || shared.length === best.shared.length && look.from === "shared")) best = { look, shared };
+          }
+          if (!best) continue;
+          const found = best;
+          if (unit.via === "attribute" && units.some((o) => o.via === "literal" && !within(o) && found.shared.every((w) => o.look.includes(w)) && looks.some((l) => copies(o.look, l.look)))) continue;
+          const loc = { start: context.sourceCode.getLocFromIndex(unit.start), end: context.sourceCode.getLocFromIndex(unit.end) };
+          const at = { start: context.sourceCode.getLocFromIndex(unit.anchor), end: loc.end };
+          if (isEscaped(context, { loc: at, range: [unit.anchor, unit.end] })) continue;
+          reported.add(unit.start);
+          const words2 = best.shared.map((w) => `\`${w}\``).join(" ");
+          if (best.look.from === "shared") context.report({ loc, messageId: "useShared", data: { part: best.look.part, file: best.look.file, words: words2 } });
+          else if (inPackage) context.report({ loc, messageId: "shareIt", data: { part: best.look.part, file: best.look.file, words: words2 } });
+          else
+            context.report({
+              loc,
+              messageId: "usePart",
+              data: { part: best.look.part, count: String(best.shared.length), words: words2, from: best.look.from === "package" ? PACKAGE2 : `\`${best.look.file}\`` }
+            });
+        }
+      }
+    };
+  }
+};
+
 // src/eslint/no-native-title.ts
 var PARTS_WITH_A_TITLE = ["CollapsibleSection", "ConfirmDialog", "ContainerHeader", "DialogShell", "ListColumn", "SectionHeader"];
 var child3 = (node, key) => node[key];
-var nameOf3 = (node) => node?.type === "JSXIdentifier" || node?.type === "Identifier" ? node.name : void 0;
+var nameOf4 = (node) => node?.type === "JSXIdentifier" || node?.type === "Identifier" ? node.name : void 0;
 var noNativeTitle = {
   meta: {
     type: "problem",
@@ -1007,10 +1378,10 @@ var noNativeTitle = {
       },
       JSXAttribute(ruleNode) {
         const attribute3 = ruleNode;
-        if (nameOf3(child3(attribute3, "name")) !== "title") return;
+        if (nameOf4(child3(attribute3, "name")) !== "title") return;
         const opening = attribute3.parent;
         const tag = child3(opening, "name");
-        const name = nameOf3(tag);
+        const name = nameOf4(tag);
         if (!(name && /^[a-z]/.test(name))) {
           const binding = locals && bindingOfTag(tag, locals);
           if (!binding || binding.props !== "all") return;
@@ -1624,7 +1995,8 @@ var appRules = {
   "no-restyled-part": noRestyledPart,
   "no-handmade-header": noHandmadeHeader,
   "no-handmade-empty-state": noHandmadeEmptyState,
-  "no-native-title": noNativeTitle
+  "no-native-title": noNativeTitle,
+  "no-copied-look": noCopiedLook
 };
 var packageRules = {
   "raw-element-outside-a-wrapper": rawElementOutsideAWrapper,
@@ -1634,7 +2006,8 @@ var packageRules = {
   "no-restyled-part": noRestyledPart,
   "no-handmade-header": noHandmadeHeader,
   "no-handmade-empty-state": noHandmadeEmptyState,
-  "no-native-title": noNativeTitle
+  "no-native-title": noNativeTitle,
+  "no-copied-look": noCopiedLook
 };
 var rules = { ...appRules, ...packageRules };
 var plugin = {
@@ -1653,7 +2026,9 @@ plugin.configs.recommended = {
     [`${PLUGIN_KEY}/no-restyled-part`]: "error",
     [`${PLUGIN_KEY}/no-handmade-header`]: "error",
     [`${PLUGIN_KEY}/no-handmade-empty-state`]: "error",
-    [`${PLUGIN_KEY}/no-native-title`]: "error"
+    [`${PLUGIN_KEY}/no-native-title`]: "error",
+    // A warning, never an error (Katerina, 13 September): likeness is a judgement.
+    [`${PLUGIN_KEY}/no-copied-look`]: "warn"
   }
 };
 plugin.configs.strict = {
@@ -1664,7 +2039,8 @@ plugin.configs.strict = {
 plugin.configs.package = {
   name: "@estiva-app/ui/package",
   plugins: { [PLUGIN_KEY]: plugin },
-  rules: Object.fromEntries(PACKAGE_RULE_IDS.map((id) => [id, "error"]))
+  // Every inward rule blocks, but the copied look, which warns here too (UIG-25).
+  rules: Object.fromEntries(PACKAGE_RULE_IDS.map((id) => [id, id === `${PLUGIN_KEY}/no-copied-look` ? "warn" : "error"]))
 };
 var index_default = plugin;
 function countGates(results, seed = APP_RULE_IDS) {
@@ -1688,7 +2064,9 @@ function countGates(results, seed = APP_RULE_IDS) {
 export {
   APP_RULE_IDS,
   ESCAPE_MARKER,
+  MIN_COVER,
   MIN_REASON,
+  MIN_SHARED,
   OWNED_BEHAVIOURS,
   PACKAGE_RULE_IDS,
   PARTS_WITH_A_TITLE,