@estiva-app/ui 0.19.0 → 0.20.0

package/dist/eslint/index.js

@@ -441,10 +441,10 @@ function anchorOf(node) {
   if (node.type === "FunctionDeclaration") {
     return node.parent && /^Export/.test(node.parent.type) ? node.parent : node;
   }
-  let child = node;
-  for (let p = node.parent; p; child = p, p = p.parent) {
+  let child2 = node;
+  for (let p = node.parent; p; child2 = p, p = p.parent) {
     if (p.type === "JSXOpeningElement" || p.type === "Property" || p.type === "MethodDefinition" || p.type === "PropertyDefinition") return p;
-    if (p.type === "ArrayExpression") return child;
+    if (p.type === "ArrayExpression") return child2;
     if (p.type !== "BlockStatement" && /(Statement|Declaration)$/.test(p.type)) return p;
   }
   return node;
@@ -714,6 +714,509 @@ var noRebuiltBehaviour = {
   }
 };
 
+// src/eslint/no-restyled-part.ts
+import { existsSync as existsSync2, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+var PLACEMENT = [
+  { what: "space around", pattern: /^m[xytrblse]?-/ },
+  { what: "space inside", pattern: /^p[xytrblse]?-/ },
+  { what: "width and height", pattern: /^(?:w|h|size|min-w|min-h|max-w|max-h)-/ },
+  { what: "shown, and how it lays out", pattern: /^(?:hidden|block|inline|inline-block|inline-flex|inline-grid|flex|grid|contents|flow-root)$/ },
+  { what: "its place in a row or a grid", pattern: /^(?: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)-/ },
+  { what: "alignment", pattern: /^(?:self|justify|justify-items|justify-self|items|place-content|place-items|place-self)-|^content-(?!\[)/ },
+  { what: "position", pattern: /^(?:static|relative|absolute|fixed|sticky)$|^(?:inset|inset-x|inset-y|top|right|bottom|left|start|end|z)-/ },
+  // Draws nothing: it names the part, so what is inside can answer its hover (`group-hover:`).
+  { what: "a name for hover", pattern: /^(?:group|peer)(?:\/[\w-]+)?$/ }
+];
+var REACHING_VARIANT = /^\[|^(?:before|after|placeholder|file|marker|selection|first-letter|first-line|backdrop|\*|\*\*)$/;
+function splitClass(token) {
+  const variants = [];
+  let current = "";
+  let depth = 0;
+  for (const character of token) {
+    if (character === "[") depth += 1;
+    if (character === "]") depth -= 1;
+    if (character === ":" && depth === 0) {
+      variants.push(current);
+      current = "";
+    } else current += character;
+  }
+  return { variants, utility: current.replace(/^!/, "").replace(/!$/, "").replace(/^-/, "") };
+}
+function isPlacement(token) {
+  const { variants, utility } = splitClass(token);
+  if (variants.some((variant) => REACHING_VARIANT.test(variant))) return false;
+  return PLACEMENT.some(({ pattern }) => pattern.test(utility));
+}
+var isPadding = (token) => {
+  const { variants, utility } = splitClass(token);
+  return !variants.some((variant) => REACHING_VARIANT.test(variant)) && /^p[xytrblse]?-/.test(utility);
+};
+var PART_LOOK_PROPS = {
+  AppShell: ["variant"],
+  Avatar: ["size"],
+  AvatarGroup: ["size"],
+  Banner: ["tone"],
+  Button: ["variant", "size"],
+  Card: ["fill", "hover", "attention", "selected", "active", "hovered", "quietUntilHover", "unreadable", "clip"],
+  Checkbox: ["row"],
+  Chip: ["type"],
+  Divider: ["tone", "orientation"],
+  EmptyState: ["scope"],
+  FieldLine: ["tone"],
+  IconButton: ["variant", "pressed", "glow"],
+  InputChip: ["truncate"],
+  Link: ["variant", "truncate"],
+  MenuItem: ["size", "selected", "destructive"],
+  MenuSub: ["selected"],
+  NavItem: ["active"],
+  Person: ["size"],
+  ProgressBar: ["variant"],
+  Property: ["layout"],
+  RailItem: ["active"],
+  Reaction: ["pressed"],
+  ReactionPicker: ["surface"],
+  SectionLabel: ["tone"],
+  Select: ["size"],
+  Tabs: ["size"],
+  TextInput: ["size"],
+  Toast: ["type"],
+  Toolbar: ["surface"],
+  ToolbarButton: ["variant", "pressed", "glow"],
+  TopBar: ["variant"]
+};
+var CLASS_PROP = /^(?:className|[a-z][A-Za-z]*ClassName)$/;
+var child = (node, key) => node[key];
+var children = (node, key) => node[key] ?? [];
+var nameOf = (node) => node?.type === "Identifier" || node?.type === "JSXIdentifier" ? node.name : node?.type === "Literal" && typeof node.value === "string" ? node.value : void 0;
+function walk(root, visit) {
+  const stack = [root];
+  while (stack.length) {
+    const node = stack.pop();
+    visit(node);
+    for (const key of Object.keys(node)) {
+      if (key === "parent" || key === "loc" || key === "range" || key === "tokens" || key === "comments") continue;
+      const value = node[key];
+      if (Array.isArray(value)) for (const item of value) {
+        if (item && typeof item.type === "string") stack.push(item);
+      }
+      else if (value && typeof value.type === "string") stack.push(value);
+    }
+  }
+}
+var PACKAGE = "@estiva-app/ui";
+var moduleCache = /* @__PURE__ */ new Map();
+var packageDirCache = /* @__PURE__ */ new Map();
+var packagePartsCache = /* @__PURE__ */ new Map();
+function parseFile(parser, filePath) {
+  const code2 = readFileSync(filePath, "utf8");
+  const options = { filePath, ecmaVersion: "latest", sourceType: "module", ecmaFeatures: { jsx: filePath.endsWith("x") }, range: true, loc: true };
+  try {
+    if (parser.parseForESLint) return parser.parseForESLint(code2, options).ast;
+    if (parser.parse) return parser.parse(code2, options);
+  } catch {
+  }
+  return null;
+}
+function packageDirOf(file) {
+  const start = dirname(resolve(file));
+  if (packageDirCache.has(start)) return packageDirCache.get(start) ?? null;
+  let dir = start;
+  for (; ; ) {
+    if (existsSync2(join(dir, "package.json"))) break;
+    const up = dirname(dir);
+    if (up === dir) {
+      dir = "";
+      break;
+    }
+    dir = up;
+  }
+  packageDirCache.set(start, dir || null);
+  return dir || null;
+}
+function resolveModule(fromFile, specifier) {
+  let base;
+  if (specifier.startsWith(".")) base = resolve(dirname(fromFile), specifier);
+  else if (specifier.startsWith("@/")) {
+    const dir = packageDirOf(fromFile);
+    if (!dir) return null;
+    base = join(dir, "src", specifier.slice(2));
+  } else return null;
+  for (const candidate of [base, `${base}.tsx`, `${base}.ts`, join(base, "index.tsx"), join(base, "index.ts")]) {
+    if (existsSync2(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+function packagePartsFor(file, parser) {
+  const dir = packageDirOf(file);
+  if (!dir) return null;
+  let name;
+  try {
+    name = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name;
+  } catch {
+    return null;
+  }
+  if (name !== PACKAGE) return null;
+  const index = join(dir, "src", "index.ts");
+  if (!existsSync2(index)) return null;
+  const mtime = statSync(index).mtimeMs;
+  const cached = packagePartsCache.get(index);
+  if (cached && cached.mtime === mtime) return cached.parts;
+  const parts = /* @__PURE__ */ new Set();
+  const ast = parseFile(parser, index);
+  for (const statement2 of ast ? children(ast, "body") : []) {
+    if (statement2?.type !== "ExportNamedDeclaration" || statement2.exportKind === "type") continue;
+    for (const specifier of children(statement2, "specifiers")) {
+      const exported = nameOf(child(specifier, "exported"));
+      if (specifier?.exportKind !== "type" && exported && /^[A-Z][a-z]/.test(exported)) parts.add(exported);
+    }
+  }
+  packagePartsCache.set(index, { mtime, parts });
+  return parts;
+}
+function functionComponents(program) {
+  const found = /* @__PURE__ */ new Map();
+  const unwrap = (node) => {
+    let current = node;
+    while (current?.type === "CallExpression" && children(current, "arguments").length) {
+      const callee = child(current, "callee");
+      const text = callee?.type === "Identifier" ? nameOf(callee) : callee?.type === "MemberExpression" ? nameOf(child(callee, "property")) : void 0;
+      if (text !== "forwardRef" && text !== "memo") return null;
+      current = children(current, "arguments")[0];
+    }
+    return current?.type === "ArrowFunctionExpression" || current?.type === "FunctionExpression" ? current : null;
+  };
+  walk(program, (node) => {
+    if (node.type === "FunctionDeclaration") {
+      const name = nameOf(child(node, "id"));
+      if (name && /^[A-Z]/.test(name)) found.set(name, node);
+    } else if (node.type === "VariableDeclarator") {
+      const name = nameOf(child(node, "id"));
+      const fn = unwrap(child(node, "init"));
+      if (name && /^[A-Z]/.test(name) && fn) found.set(name, fn);
+    }
+  });
+  return found;
+}
+function moduleParts(file, program, parser, stack) {
+  const locals = /* @__PURE__ */ new Map();
+  const packageParts = packagePartsFor(file, parser);
+  const body = children(program, "body");
+  const exportsOf = (specifier) => {
+    if (specifier === PACKAGE) return "package";
+    const target = resolveModule(file, specifier);
+    if (!target) return null;
+    if (packageParts) return "package";
+    return moduleExports(target, parser, stack);
+  };
+  for (const statement2 of body) {
+    if (statement2?.type !== "ImportDeclaration" || statement2.importKind === "type") continue;
+    const source = exportsOf(String(child(statement2, "source").value));
+    if (!source) continue;
+    for (const specifier of children(statement2, "specifiers")) {
+      if (!specifier || specifier.importKind === "type") continue;
+      const local = nameOf(child(specifier, "local"));
+      if (!local) continue;
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        if (source === "package" && !packageParts) locals.set(local, "namespace");
+        continue;
+      }
+      const imported = specifier.type === "ImportDefaultSpecifier" ? "default" : nameOf(child(specifier, "imported"));
+      if (!imported) continue;
+      if (source === "package") {
+        const isPart = packageParts ? packageParts.has(imported) : /^[A-Z]/.test(imported);
+        if (isPart) locals.set(local, { part: imported, props: "all" });
+      } else if (source.has(imported)) locals.set(local, source.get(imported));
+    }
+  }
+  const components = functionComponents(program);
+  if (packageParts) {
+    for (const name of components.keys()) if (packageParts.has(name) && !locals.has(name)) locals.set(name, { part: name, props: "all" });
+  }
+  if (!packageParts) {
+    let changed = true;
+    for (let round = 0; changed && round < 10; round += 1) {
+      changed = false;
+      for (const [name, fn] of components) {
+        const binding = handsOnTo(fn, (tag) => bindingOfTag(tag, locals));
+        if (!binding) continue;
+        const next = { ...binding, via: name };
+        const previous = locals.get(name);
+        if (!previous || JSON.stringify(previous) !== JSON.stringify(next)) {
+          if (previous && previous !== "namespace" && !previous.via) continue;
+          locals.set(name, next);
+          changed = true;
+        }
+      }
+    }
+  }
+  const exports = /* @__PURE__ */ new Map();
+  const localBinding = (name) => {
+    const binding = name ? locals.get(name) : void 0;
+    return binding && binding !== "namespace" ? binding : void 0;
+  };
+  for (const statement2 of body) {
+    if (!statement2) continue;
+    if (statement2.type === "ExportNamedDeclaration") {
+      const declaration = child(statement2, "declaration");
+      if (declaration?.type === "FunctionDeclaration") {
+        const name = nameOf(child(declaration, "id"));
+        const binding = localBinding(name);
+        if (name && binding) exports.set(name, binding);
+      } else if (declaration?.type === "VariableDeclaration") {
+        for (const declarator of children(declaration, "declarations")) {
+          const name = nameOf(child(declarator, "id"));
+          const init = child(declarator, "init");
+          const binding = localBinding(name) ?? (init?.type === "Identifier" ? localBinding(nameOf(init)) : void 0);
+          if (name && binding) exports.set(name, binding);
+        }
+      }
+      const source = child(statement2, "source");
+      const from = source ? exportsOf(String(source.value)) : null;
+      for (const specifier of children(statement2, "specifiers")) {
+        if (!specifier || specifier.exportKind === "type") continue;
+        const local = nameOf(child(specifier, "local"));
+        const exported = nameOf(child(specifier, "exported"));
+        if (!local || !exported) continue;
+        if (!source) {
+          const binding = localBinding(local);
+          if (binding) exports.set(exported, binding);
+        } else if (from === "package") {
+          if (/^[A-Z]/.test(local)) exports.set(exported, { part: local, props: "all" });
+        } else if (from?.has(local)) exports.set(exported, from.get(local));
+      }
+    } else if (statement2.type === "ExportAllDeclaration" && !child(statement2, "exported")) {
+      const from = exportsOf(String(child(statement2, "source").value));
+      if (from && from !== "package") for (const [name, binding] of from) exports.set(name, binding);
+    } else if (statement2.type === "ExportDefaultDeclaration") {
+      const declaration = child(statement2, "declaration");
+      const name = declaration?.type === "Identifier" ? nameOf(declaration) : nameOf(child(declaration, "id"));
+      const binding = localBinding(name);
+      if (binding) exports.set("default", binding);
+    }
+  }
+  return { locals, exports };
+}
+function moduleExports(file, parser, stack) {
+  const mtime = statSync(file).mtimeMs;
+  const cached = moduleCache.get(file);
+  if (cached && cached.mtime === mtime) return cached.exports;
+  if (stack.has(file)) return /* @__PURE__ */ new Map();
+  stack.add(file);
+  const program = parseFile(parser, file);
+  const exports = program ? moduleParts(file, program, parser, stack).exports : /* @__PURE__ */ new Map();
+  stack.delete(file);
+  moduleCache.set(file, { mtime, exports });
+  return exports;
+}
+function bindingOfTag(tag, locals) {
+  if (!tag) return void 0;
+  if (tag.type === "JSXIdentifier") {
+    const binding = locals.get(tag.name);
+    return binding && binding !== "namespace" ? binding : void 0;
+  }
+  if (tag.type === "JSXMemberExpression") {
+    const object = child(tag, "object");
+    const property = nameOf(child(tag, "property"));
+    if (object?.type === "JSXIdentifier" && locals.get(object.name) === "namespace" && property) return { part: property, props: "all" };
+  }
+  return void 0;
+}
+function handsOnTo(fn, bindingOf) {
+  const param = children(fn, "params")[0];
+  if (!param) return void 0;
+  let restName;
+  let propsName;
+  const classParams = /* @__PURE__ */ new Map();
+  if (param.type === "ObjectPattern") {
+    for (const property of children(param, "properties")) {
+      if (!property) continue;
+      if (property.type === "RestElement") restName = nameOf(child(property, "argument"));
+      else if (property.type === "Property") {
+        const key = nameOf(child(property, "key"));
+        let value = child(property, "value");
+        if (value?.type === "AssignmentPattern") value = child(value, "left");
+        const local = nameOf(value);
+        if (key && local && CLASS_PROP.test(key)) classParams.set(local, key);
+      }
+    }
+  } else if (param.type === "Identifier") propsName = nameOf(param);
+  let wrapper;
+  const forwarded = { props: {} };
+  const body = child(fn, "body");
+  if (!body) return void 0;
+  walk(body, (node) => {
+    if (wrapper || node.type !== "JSXOpeningElement") return;
+    const binding = bindingOf(child(node, "name"));
+    if (!binding) return;
+    for (const attribute2 of children(node, "attributes")) {
+      if (!attribute2) continue;
+      if (attribute2.type === "JSXSpreadAttribute") {
+        const argument = nameOf(child(attribute2, "argument"));
+        if (argument && (argument === restName || argument === propsName)) wrapper = { part: binding.part, props: binding.props };
+        continue;
+      }
+      const prop = nameOf(child(attribute2, "name"));
+      if (!prop || !CLASS_PROP.test(prop)) continue;
+      const partProp = binding.props === "all" ? prop : binding.props[prop];
+      if (!partProp) continue;
+      walk(attribute2, (inner) => {
+        let callerProp;
+        if (inner.type === "Identifier") callerProp = classParams.get(inner.name);
+        if (inner.type === "MemberExpression" && nameOf(child(inner, "object")) === propsName) {
+          const key = nameOf(child(inner, "property"));
+          if (key && CLASS_PROP.test(key)) callerProp = key;
+        }
+        if (!callerProp) return;
+        if (forwarded.part && forwarded.part !== binding.part) return;
+        forwarded.part = binding.part;
+        forwarded.props[callerProp] = partProp;
+      });
+    }
+  });
+  if (wrapper) return wrapper;
+  return forwarded.part ? { part: forwarded.part, props: forwarded.props } : void 0;
+}
+var CLASS_FUNCTIONS = /* @__PURE__ */ new Set(["cn", "clsx", "cx", "twMerge", "classNames"]);
+function constantOf(identifier, scope) {
+  let current = scope;
+  while (current) {
+    const variable = current.set.get(identifier.name);
+    if (variable) {
+      const definition = variable.defs[0];
+      if (variable.defs.length !== 1 || definition?.type !== "Variable") return void 0;
+      if (definition.parent?.kind !== "const") return void 0;
+      return child(definition.node, "init") ?? void 0;
+    }
+    current = current.upper;
+  }
+  return void 0;
+}
+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) : [];
+  switch (value.type) {
+    case "Literal":
+      return words(value.value);
+    case "TemplateLiteral":
+      return [...children(value, "quasis").flatMap((quasi) => words((quasi?.value).cooked)), ...children(value, "expressions").flatMap((e) => read(e))];
+    case "JSXExpressionContainer":
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+    case "ChainExpression":
+      return read(child(value, "expression"), asMap);
+    case "ConditionalExpression":
+      return [...read(child(value, "consequent")), ...read(child(value, "alternate"))];
+    case "LogicalExpression":
+      return value.operator === "&&" ? read(child(value, "right")) : [...read(child(value, "left")), ...read(child(value, "right"))];
+    case "BinaryExpression":
+      return value.operator === "+" ? [...read(child(value, "left")), ...read(child(value, "right"))] : [];
+    case "ArrayExpression":
+      return children(value, "elements").flatMap((e) => read(e));
+    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")));
+      });
+    case "CallExpression": {
+      const callee = child(value, "callee");
+      return callee?.type === "Identifier" && CLASS_FUNCTIONS.has(callee.name) ? children(value, "arguments").flatMap((a) => read(a)) : [];
+    }
+    case "Identifier": {
+      const constant = constantOf(value, scopeOf(value));
+      return constant ? read(constant, asMap) : [];
+    }
+    case "MemberExpression": {
+      const object = child(value, "object");
+      const target = object?.type === "Identifier" ? constantOf(object, scopeOf(object)) : object;
+      const map = target?.type === "TSAsExpression" || target?.type === "TSSatisfiesExpression" ? child(target, "expression") : target;
+      if (map?.type !== "ObjectExpression") return [];
+      const property = child(value, "property");
+      const key = value.computed ? property?.type === "Literal" ? String(property.value) : void 0 : nameOf(property);
+      return children(map, "properties").flatMap((entry) => {
+        if (entry?.type !== "Property") return [];
+        if (key !== void 0 && nameOf(child(entry, "key")) !== key) return [];
+        return read(child(entry, "value"), true);
+      });
+    }
+    default:
+      return [];
+  }
+}
+var code = (items) => items.map((item) => `\`${item}\``).join(" ");
+var or = (items) => items.length === 1 ? code(items) : `${items.slice(0, -1).map((i) => `\`${i}\``).join(", ")} or \`${items[items.length - 1]}\``;
+var noRestyledPart = {
+  meta: {
+    type: "problem",
+    docs: { description: "Only placement passes into a part of @estiva-app/ui through a class prop" },
+    schema: [],
+    messages: {
+      restyled: "{{classes}} on {{where}} changes how it looks. A part of @estiva-app/ui is placed from outside, never restyled: only space, size, flex and grid, and position pass in.{{use}} A look for what is around it goes on your own element around it.",
+      emptyStatePadding: "{{classes}} pads {{where}}. EmptyState takes no padding (Katerina, 14 September): its room comes from the box its rows live in, so put the padding on that box.",
+      ...ESCAPE_MESSAGES
+    }
+  },
+  create(context) {
+    const parser = context.languageOptions?.parser ?? {};
+    const file = context.filename;
+    const sourceCode = context.sourceCode;
+    const scopeOf = (node) => sourceCode.getScope(node);
+    let locals;
+    const escapes = /* @__PURE__ */ new Map();
+    const escaped = (anchor) => {
+      if (!escapes.has(anchor)) escapes.set(anchor, isEscaped(context, anchor));
+      return escapes.get(anchor) === true;
+    };
+    const check = (element, binding, prop, value, at) => {
+      const partProp = binding.props === "all" ? prop : binding.props[prop];
+      if (!partProp || !value) return;
+      const classes = classesOf(value, scopeOf);
+      const handedOn = binding.props === "all" ? "its props" : `its \`${prop}\``;
+      const via = binding.via && binding.via !== binding.part ? `\`${binding.via}\` (it hands ${handedOn} to \`${binding.part}\`)` : `\`${binding.part}\``;
+      const where = `${via}${partProp === "className" ? "" : `'s \`${partProp}\``}`;
+      const restyled = [...new Set(classes.filter((token) => !isPlacement(token)))];
+      const padding = binding.part === "EmptyState" && binding.props === "all" ? [...new Set(classes.filter(isPadding))] : [];
+      if (!restyled.length && !padding.length) return;
+      if (escaped(element)) return;
+      if (restyled.length) {
+        const props = PART_LOOK_PROPS[binding.part];
+        const use = props ? ` Use its ${or(props)}.` : ` \`${binding.part}\` has no prop for this yet: ask Katerina, and it gets made in @estiva-app/ui.`;
+        context.report({ loc: at.loc, messageId: "restyled", data: { classes: code(restyled), where, use } });
+      }
+      if (padding.length) context.report({ loc: at.loc, messageId: "emptyStatePadding", data: { classes: code(padding), where } });
+    };
+    return {
+      Program(program) {
+        locals = moduleParts(file, program, parser, /* @__PURE__ */ new Set([file])).locals;
+      },
+      JSXOpeningElement(ruleNode) {
+        const element = ruleNode;
+        const binding = locals && bindingOfTag(child(element, "name"), locals);
+        if (!binding) return;
+        for (const attribute2 of children(element, "attributes")) {
+          if (!attribute2) continue;
+          if (attribute2.type === "JSXAttribute") {
+            const prop = nameOf(child(attribute2, "name"));
+            if (prop && CLASS_PROP.test(prop)) check(element, binding, prop, child(attribute2, "value"), attribute2);
+            continue;
+          }
+          let spread = child(attribute2, "argument");
+          if (spread?.type === "Identifier") spread = constantOf(spread, scopeOf(spread));
+          while (spread?.type === "TSAsExpression" || spread?.type === "TSSatisfiesExpression") spread = child(spread, "expression");
+          if (spread?.type !== "ObjectExpression") continue;
+          for (const property of children(spread, "properties")) {
+            const key = property?.type === "Property" && !property.computed ? nameOf(child(property, "key")) : void 0;
+            if (key && CLASS_PROP.test(key)) check(element, binding, key, child(property, "value"), property);
+          }
+        }
+      }
+    };
+  }
+};
+
 // src/eslint/raw-element-outside-a-wrapper.ts
 var RAW_ELEMENTS = /* @__PURE__ */ new Set(["a", "button", "input", "textarea", "select", "dialog", "form", "label"]);
 var rawElementOutsideAWrapper = {
@@ -755,13 +1258,15 @@ var { version } = createRequire(import.meta.url)("../../package.json");
 var PLUGIN_KEY = "estiva";
 var appRules = {
   "no-raw-element": noRawElement,
-  "no-rebuilt-behaviour": noRebuiltBehaviour
+  "no-rebuilt-behaviour": noRebuiltBehaviour,
+  "no-restyled-part": noRestyledPart
 };
 var packageRules = {
   "raw-element-outside-a-wrapper": rawElementOutsideAWrapper,
   "no-hand-rolled-behaviour": noHandRolledBehaviour,
   "component-has-a-page": componentHasAPage,
-  "component-has-a-story": componentHasAStory
+  "component-has-a-story": componentHasAStory,
+  "no-restyled-part": noRestyledPart
 };
 var rules = { ...appRules, ...packageRules };
 var plugin = {
@@ -776,7 +1281,8 @@ plugin.configs.recommended = {
   plugins: { [PLUGIN_KEY]: plugin },
   rules: {
     [`${PLUGIN_KEY}/no-raw-element`]: "error",
-    [`${PLUGIN_KEY}/no-rebuilt-behaviour`]: "error"
+    [`${PLUGIN_KEY}/no-rebuilt-behaviour`]: "error",
+    [`${PLUGIN_KEY}/no-restyled-part`]: "error"
   }
 };
 plugin.configs.strict = {
@@ -814,6 +1320,8 @@ export {
   MIN_REASON,
   OWNED_BEHAVIOURS,
   PACKAGE_RULE_IDS,
+  PART_LOOK_PROPS,
+  PLACEMENT,
   PLUGIN_KEY,
   SETTINGS_KEY,
   countGates,