@navecss/core 0.2.0 → 0.4.0

package/dist/postcss.js

@@ -1,314 +1,308 @@
-import { atoms } from './chunk-BVON7XKC.js';
+import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
+import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-LADFXRWQ.js';
+import { tokenize } from './chunk-NFS2REPQ.js';
+import { formatDiagnostic } from './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import './chunk-GZL2VW7C.js';
 import postcss from 'postcss';
 
-// src/selector-utils.ts
-function isCommentClose(text, index, commentStart) {
-  return text[index] === "/" && text[index - 1] === "*" && index - 1 >= commentStart + 2;
+// src/postcss-nested-builders.ts
+function isNestedNode(node) {
+  return node.type === "rule" || node.type === "atrule" && node.name.toLowerCase() !== "nave";
 }
-function isConsumedAsLiteral(state, text, index) {
-  if (state.commentStart !== void 0) {
-    if (isCommentClose(text, index, state.commentStart)) state.commentStart = void 0;
-    return true;
-  }
-  if (state.isEscaped) {
-    state.isEscaped = false;
-    return true;
-  }
-  if (text[index] === "\\") {
-    state.isEscaped = true;
-    return true;
+function isFollowingNestedNode(rule, atRule) {
+  return rule.nodes.slice(0, rule.index(atRule)).some((node) => isNestedNode(node));
+}
+
+// src/postcss-node-utils.ts
+function isInsideKeyframes(container) {
+  let node = container;
+  while (node) {
+    if (node.type === "atrule" && /keyframes$/i.test(node.name)) return true;
+    node = node.parent;
   }
-  if (!state.quote) return false;
-  if (text[index] === state.quote) state.quote = void 0;
-  return true;
+  return false;
 }
-function isCodeChar(state, text, index) {
-  if (isConsumedAsLiteral(state, text, index)) return false;
-  const char = text[index];
-  if (char === '"' || char === "'") {
-    state.quote = char;
+function hasWorkaroundSentence(refusedParent) {
+  if (refusedParent.type !== "atrule") return false;
+  if (!WORKAROUND_GROUP_AT_RULE_NAMES.has(refusedParent.name.toLowerCase())) {
     return false;
   }
-  if (char === "/" && text[index + 1] === "*") {
-    state.commentStart = index;
-    return false;
+  if (isInsideKeyframes(refusedParent)) return false;
+  let current = refusedParent.parent;
+  while (current) {
+    if (current.type === "rule") return true;
+    current = current.parent;
   }
-  return true;
+  return false;
+}
+function stampSource(node, source) {
+  if (!source) return;
+  node.source = source;
+  node.walk((child) => {
+    child.source = source;
+  });
+}
+
+// src/postcss-at-rule.ts
+function currentParams(atRule) {
+  const raw = atRule.raws.params;
+  if (raw?.value === atRule.params) return raw.raw;
+  return atRule.params;
 }
-function codeMask(text) {
-  const state = { quote: void 0, isEscaped: false, commentStart: void 0 };
-  return Array.from({ length: text.length }, (_, index) => isCodeChar(state, text, index));
+function matchNaveAtRule(atRule) {
+  const afterName = atRule.raws.afterName ?? " ";
+  const paramsRaw = currentParams(atRule);
+  const nameBoundary = 1 + atRule.name.length;
+  const full = `@${atRule.name}${afterName}${paramsRaw}`;
+  const token = tokenize(full)[0];
+  const commonPrelude = { prelude: paramsRaw, preludeStartIndex: nameBoundary + afterName.length };
+  if (token?.type !== "at-keyword-token") return { isNave: false, ...commonPrelude };
+  const isNave = (token.structured?.value).toLowerCase() === "nave";
+  if (token.endIndex === nameBoundary) return { isNave, ...commonPrelude };
+  return { isNave, prelude: full.slice(token.endIndex), preludeStartIndex: token.endIndex };
 }
-function splitTopLevel(selectorList) {
-  const mask = codeMask(selectorList);
-  const branches = [];
-  let depth = 0;
-  let start = 0;
-  for (const [index, isCode] of mask.entries()) {
-    if (!isCode) continue;
-    const char = selectorList[index];
-    if (char === "(" || char === "[") depth += 1;
-    else if (char === ")" || char === "]") depth -= 1;
-    else if (char === "," && depth === 0) {
-      branches.push(selectorList.slice(start, index));
-      start = index + 1;
+function atRuleErrorIndex(preludeStartIndex, diagnostic) {
+  if (diagnostic.code !== "unknown-atom" && diagnostic.code !== "bad-token") return void 0;
+  return preludeStartIndex + diagnostic.offset;
+}
+function reportDiagnostic(diagnostic, ctx, preludeStartIndex) {
+  const refusedParent = ctx.atRule.parent;
+  const isNestedGroup = diagnostic.code === "bad-parent" && refusedParent !== void 0 && hasWorkaroundSentence(refusedParent);
+  const text = formatDiagnostic(
+    isNestedGroup ? { ...diagnostic, detail: "nested-group" } : diagnostic,
+    {
+      extend: ctx.extend
     }
+  );
+  const index = atRuleErrorIndex(preludeStartIndex, diagnostic);
+  if (ctx.onUnknown === "warn") {
+    ctx.atRule.warn(ctx.result, text, index === void 0 ? {} : { index });
+    return;
   }
-  return [...branches, selectorList.slice(start)];
+  if (ctx.onUnknown === "ignore") return;
+  ctx.fold.push({ atRule: ctx.atRule, text, index });
 }
-function hasNestingSelector(branch) {
-  return codeMask(branch).some((isCode, index) => isCode && branch[index] === "&");
+function declNode(atRule, decl) {
+  const node = postcss.decl({ prop: decl.prop, value: decl.value });
+  if (atRule.source) node.source = atRule.source;
+  return node;
 }
-function anchorSelectorList(selectorList) {
-  return splitTopLevel(selectorList).map((branch) => {
-    const trimmed = branch.trim();
-    if (trimmed === "") {
-      throw new Error(
-        `anchorSelectorList: empty selector branch in pseudo key "${selectorList}". Remove the stray or trailing comma: an empty branch would otherwise compile to a bare "&", matching the atom unconditionally.`
-      );
-    }
-    return hasNestingSelector(trimmed) ? trimmed : `&${trimmed}`;
-  }).join(", ");
+function insertDeclarations(atRule, declarations, isWrapped) {
+  if (declarations.length === 0) return;
+  if (!isWrapped) {
+    for (const decl of declarations) atRule.before(declNode(atRule, decl));
+    return;
+  }
+  const wrapper = postcss.rule({ selector: "&" });
+  if (atRule.source) wrapper.source = atRule.source;
+  for (const decl of declarations) wrapper.append(declNode(atRule, decl));
+  atRule.before(wrapper);
 }
-
-// src/postcss-nested-builders.ts
-var DIRECTIVE = "nave";
-function buildNestedRule(selector, decls) {
+function buildRule(selector, declarations) {
   const rule = postcss.rule({ selector });
-  for (const [prop, value] of Object.entries(decls)) {
-    rule.append(postcss.decl({ prop, value }));
-  }
+  for (const decl of declarations) rule.append(postcss.decl({ prop: decl.prop, value: decl.value }));
   return rule;
 }
-function buildPseudoRules(pseudos) {
-  return Object.entries(pseudos).map(
-    ([pseudo, decls]) => buildNestedRule(anchorSelectorList(pseudo), decls)
-  );
+function buildAppendedNode(block) {
+  if (block.kind === "pseudo") return buildRule(block.selector, block.declarations);
+  const node = postcss.atRule({ name: block.kind, params: block.condition });
+  if (block.declarations.length > 0) node.append(buildRule("&", block.declarations));
+  for (const pseudo of block.pseudos) node.append(buildRule(pseudo.selector, pseudo.declarations));
+  return node;
 }
-function buildInnerRules(block) {
-  const rules = [];
-  if (block.declarations) rules.push(buildNestedRule("&", block.declarations));
-  if (block.pseudos) rules.push(...buildPseudoRules(block.pseudos));
-  return rules;
+function throwMalformedAtom(atRule, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  throw atRule.error(message);
 }
-function buildAtBlock(atName, condition, block) {
-  const inner = buildInnerRules(block);
-  if (inner.length === 0) return void 0;
-  const node = postcss.atRule({ name: atName, params: condition });
-  for (const rule of inner) node.append(rule);
-  return node;
+function planAtRule(atRule, extend, prelude) {
+  const parent = atRule.parent;
+  const isStyleRuleParent = parent?.type === "rule";
+  const isFollowingNestedNodeHere = isStyleRuleParent ? isFollowingNestedNode(parent, atRule) : false;
+  try {
+    return {
+      isStyleRuleParent,
+      parent,
+      result: plan(
+        prelude,
+        {
+          isStyleRuleParent,
+          isInsideKeyframes: parent !== void 0 && isInsideKeyframes(parent),
+          isFollowingNestedNode: isFollowingNestedNodeHere
+        },
+        { extend }
+      )
+    };
+  } catch (error) {
+    return throwMalformedAtom(atRule, error);
+  }
 }
-function buildNested(atom) {
-  const nodes = [];
-  if (atom.pseudos) nodes.push(...buildPseudoRules(atom.pseudos));
-  for (const atName of ["media", "container"]) {
-    const blocks = atom[atName] ?? {};
-    for (const [condition, block] of Object.entries(blocks)) {
-      const node = buildAtBlock(atName, condition, block);
-      if (node) nodes.push(node);
+function hasBlock(atRule) {
+  return atRule.nodes !== void 0;
+}
+function handleAtRule(atRule, ctx) {
+  const match = matchNaveAtRule(atRule);
+  if (!match.isNave) return;
+  const fullCtx = { ...ctx, atRule };
+  const {
+    isStyleRuleParent,
+    parent,
+    result: planResult
+  } = planAtRule(atRule, ctx.extend, match.prelude);
+  for (const diagnostic of planResult.diagnostics) {
+    reportDiagnostic(diagnostic, fullCtx, match.preludeStartIndex);
+  }
+  if (hasBlock(atRule)) {
+    reportDiagnostic(
+      { code: "has-block", offset: 0, endOffset: atRule.toString().length },
+      fullCtx,
+      match.preludeStartIndex
+    );
+  }
+  insertDeclarations(atRule, planResult.declarations, planResult.wrapInAmpersand);
+  atRule.remove();
+  if (isStyleRuleParent && parent) {
+    for (const block of planResult.blocks) {
+      const node = buildAppendedNode(block);
+      stampSource(node, atRule.source);
+      parent.append(node);
     }
   }
-  return nodes;
 }
-function isNestedNode(node) {
-  return node.type === "rule" || node.type === "atrule" && node.name !== DIRECTIVE;
+
+// src/postcss-fold.ts
+function positionOf(entry, fallbackLine) {
+  if (!entry.atRule.source) return { column: 0, line: fallbackLine };
+  return entry.atRule.positionBy(entry.index === void 0 ? {} : { index: entry.index });
 }
-function isFollowingNestedNode(rule, atRule) {
-  return rule.nodes.slice(0, rule.index(atRule)).some((node) => isNestedNode(node));
+function sortFoldBySourceOrder(entries) {
+  return entries.map((entry, originalIndex) => ({ entry, originalIndex })).toSorted((a, b) => {
+    const pa = positionOf(a.entry, a.originalIndex);
+    const pb = positionOf(b.entry, b.originalIndex);
+    return pa.line - pb.line || pa.column - pb.column;
+  }).map(({ entry }) => entry);
 }
-
-// src/postcss-node-utils.ts
-function isInsideKeyframes(rule) {
-  let node = rule.parent;
-  while (node) {
-    if (node.type === "atrule" && /keyframes$/i.test(node.name)) return true;
-    node = node.parent;
-  }
-  return false;
+function foldMessage(entries) {
+  return foldLocated(
+    entries.map((entry, i) => {
+      const position = positionOf(entry, i);
+      return { text: entry.text, line: position.line, column: position.column };
+    })
+  );
 }
-function stampSource(node, source) {
-  if (!source) return;
-  node.source = source;
-  node.walk((child) => {
-    child.source = source;
-  });
+function unescapeHtml(text) {
+  return text.replaceAll(/\\3c (?=\/?style\b|!--)/gi, "<");
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function compact(text) {
+  return text.replaceAll(/\s+/g, "");
 }
-function isDeclarationValid(prop, value) {
+function declarationRefusal(prop, value) {
   let root;
   try {
     root = postcss.parse(`a{${prop}:${value}}`);
   } catch {
-    return false;
+    return "break-out";
   }
-  if (root.nodes.length !== 1) return false;
+  if (root.nodes.length !== 1) return "break-out";
   const rule = root.nodes[0];
-  if (rule.type !== "rule" || rule.nodes.length !== 1) return false;
+  if (rule.type !== "rule" || rule.nodes.length !== 1) return "break-out";
   const decl = rule.nodes[0];
-  if (decl.type !== "decl") return false;
-  return decl.prop === prop && decl.toString() === `${prop}:${value}`.trimEnd();
+  if (decl.type !== "decl" || decl.prop !== prop) return "break-out";
+  const given = `${prop}:${value}`;
+  const written = decl.toString();
+  if (written === given.trimEnd()) return void 0;
+  return compact(unescapeHtml(written)) === compact(given) ? "rewritten" : "break-out";
 }
-function isPropValid(prop) {
-  return isDeclarationValid(prop, "0");
+function propRefusal(prop) {
+  return declarationRefusal(prop, "0");
 }
-function isSelectorValid(key) {
+function selectorRefusal(key) {
   let selector;
   try {
     selector = anchorSelectorList(key);
   } catch {
-    return false;
+    return "break-out";
   }
   let root;
   try {
     root = postcss.parse(`${selector}{}`);
   } catch {
-    return false;
+    return "break-out";
   }
-  if (root.nodes.length !== 1) return false;
+  if (root.nodes.length !== 1) return "break-out";
   const rule = root.nodes[0];
-  return rule.type === "rule" && rule.selector === selector && rule.nodes.length === 0;
+  const isOneEmptyRule = rule.type === "rule" && rule.selector === selector;
+  return isOneEmptyRule && rule.nodes.length === 0 ? void 0 : "break-out";
 }
-function isConditionValid(atName, condition) {
+function conditionRefusal(atName, condition) {
   let root;
   try {
     root = postcss.parse(`@${atName} ${condition}{}`);
   } catch {
-    return false;
+    return "break-out";
   }
-  if (root.nodes.length !== 1) return false;
+  if (root.nodes.length !== 1) return "break-out";
   const node = root.nodes[0];
-  return node.type === "atrule" && node.name === atName && node.params === condition.trim() && (node.nodes?.length ?? 0) === 0;
-}
-function fail(describedAs, value) {
-  throw new Error(
-    `navePlugin({ extend }): ${describedAs} does not parse as a single CSS declaration, selector or condition, and would break out of the rule it is spliced into: ${JSON.stringify(value)}. extend is trusted, consumer-authored code, not sanitised input \u2014 fix the atom definition.`
-  );
-}
-function assertDeclarationsSafe(declarations, where) {
-  if (!isPlainObject(declarations)) return;
-  for (const [prop, value] of Object.entries(declarations)) {
-    if (typeof prop === "string" && !isPropValid(prop)) {
-      fail(`${where}'s declaration property "${prop}"`, prop);
-    }
-    if (typeof value === "string" && !isDeclarationValid(prop, value)) {
-      fail(`${where}'s declaration value for "${prop}"`, value);
-    }
-  }
-}
-function assertPseudosSafe(pseudos, where) {
-  if (!isPlainObject(pseudos)) return;
-  for (const [pseudo, declarations] of Object.entries(pseudos)) {
-    if (!isSelectorValid(pseudo)) fail(`${where}'s pseudo "${pseudo}"`, pseudo);
-    assertDeclarationsSafe(declarations, `${where}'s pseudo "${pseudo}"`);
-  }
-}
-function assertAtBlocksSafe(blocks, atName, where) {
-  if (!isPlainObject(blocks)) return;
-  for (const [condition, block] of Object.entries(blocks)) {
-    if (!isConditionValid(atName, condition))
-      fail(`${where}'s ${atName} condition "${condition}"`, condition);
-    if (!isPlainObject(block)) continue;
-    const blockWhere = `${where}'s ${atName} "${condition}"`;
-    assertDeclarationsSafe(block.declarations, blockWhere);
-    assertPseudosSafe(block.pseudos, blockWhere);
+  if (node.type !== "atrule" || node.name !== atName || (node.nodes?.length ?? 0) !== 0) {
+    return "break-out";
   }
+  if (node.params === condition.trim()) return void 0;
+  return compact(node.params) === compact(condition) ? "rewritten" : "break-out";
 }
 function validateExtendAtoms(extend) {
-  for (const [name, atom] of Object.entries(extend)) {
-    if (!atom) continue;
-    const where = `atom "${name}"`;
-    assertDeclarationsSafe(atom.declarations, where);
-    assertPseudosSafe(atom.pseudos, where);
-    assertAtBlocksSafe(atom.media, "media", where);
-    assertAtBlocksSafe(atom.container, "container", where);
-  }
+  walkExtendAtoms(extend, { declarationRefusal, propRefusal, selectorRefusal, conditionRefusal });
 }
 
 // src/postcss.ts
-function reportUnknown(msg, ctx) {
-  const { atRule, onUnknown, result } = ctx;
-  if (onUnknown === "warn") {
-    atRule.warn(result, msg);
-    return;
-  }
-  if (onUnknown === "ignore") return;
-  throw atRule.error(msg);
-}
-function checkUnknownAtoms(names, validAtomNames, ctx) {
-  if (names.length === 0) {
-    reportUnknown("@nave: directive names no atom", ctx);
-    return;
-  }
-  for (const name of names) {
-    if (validAtomNames.has(name)) continue;
-    reportUnknown(
-      `@nave: unknown atom "${name}". Available: ${[...validAtomNames].join(", ")}`,
-      ctx
-    );
-  }
-}
-function insertDeclarations(atRule, declNodes, isFollowingNested) {
-  if (declNodes.length === 0) return;
-  if (!isFollowingNested) {
-    for (const decl of declNodes) atRule.before(decl);
-    return;
-  }
-  const wrapper = postcss.rule({ selector: "&" });
-  if (atRule.source) wrapper.source = atRule.source;
-  for (const decl of declNodes) wrapper.append(decl);
-  atRule.before(wrapper);
-}
 var navePlugin = (options = {}) => {
-  const { onUnknown = "error", extend = {} } = options;
-  validateExtendAtoms(extend);
-  const allAtoms = { ...atoms, ...extend };
-  const validAtomNames = new Set(
-    Object.entries(allAtoms).filter(([, definition]) => definition).map(([name]) => name)
-  );
+  const { onUnknown = "error", extend: extendOption } = options;
+  const extendFile = typeof extendOption === "string" ? resolveExtendSpecifier(extendOption) : void 0;
+  const staticExtend = typeof extendOption === "object" ? snapshotExtendMap(extendOption) : {};
+  validateExtendAtoms(staticExtend);
+  const loadCache = /* @__PURE__ */ new Map();
   return {
     postcssPlugin: "postcss-nave",
-    AtRule(atRule, { result }) {
-      if (atRule.name !== DIRECTIVE) return;
-      const ctx = { atRule, onUnknown, result };
-      const parent = atRule.parent;
-      if (parent?.type !== "rule") {
-        reportUnknown("@nave must be the direct child of a CSS rule selector block", ctx);
-        atRule.remove();
-        return;
-      }
-      const rule = parent;
-      if (isInsideKeyframes(rule)) {
-        reportUnknown("@nave cannot be used inside @keyframes", ctx);
-        atRule.remove();
-        return;
-      }
-      const names = atRule.params.trim().split(/\s+/).filter(Boolean);
-      checkUnknownAtoms(names, validAtomNames, ctx);
-      const declNodes = [];
-      const nested = names.flatMap((name) => {
-        const atom = Object.hasOwn(allAtoms, name) ? allAtoms[name] : void 0;
-        if (!atom) return [];
-        if (typeof atom.declarations !== "object" || atom.declarations === null || Array.isArray(atom.declarations)) {
-          throw atRule.error(`@nave: atom "${name}" is registered without a declarations object`);
-        }
-        for (const [prop, value] of Object.entries(atom.declarations)) {
-          const decl = postcss.decl({ prop, value });
-          if (atRule.source) decl.source = atRule.source;
-          declNodes.push(decl);
+    // Per-run state lives here, not in the factory closure above: PostCSS
+    // calls `prepare(result)` once per `Result`, so two stylesheets sharing
+    // one `navePlugin()` instance never share a `fold` or a resolved
+    // `extend`, however their async hooks interleave (otherwise one
+    // stylesheet's problems, or its loaded `extend`, could leak into another's).
+    prepare(result) {
+      const fold = [];
+      let extend = staticExtend;
+      return {
+        Once() {
+          fold.length = 0;
+          if (extendFile === void 0) return;
+          result.messages.push({
+            type: "dependency",
+            plugin: "postcss-nave",
+            file: extendFile,
+            parent: result.opts.from
+          });
+          return applyExtendModule(extendFile, loadCache, (value) => {
+            const snapshot = snapshotExtendMap(value);
+            validateExtendAtoms(snapshot);
+            extend = snapshot;
+          });
+        },
+        AtRule(atRule) {
+          handleAtRule(atRule, { onUnknown, result, extend, fold });
+        },
+        OnceExit() {
+          if (fold.length === 0) return;
+          const ordered = sortFoldBySourceOrder(fold);
+          const first = ordered[0];
+          throw first.atRule.error(
+            foldMessage(ordered),
+            first.index === void 0 ? {} : { index: first.index }
+          );
         }
-        return buildNested(atom);
-      });
-      insertDeclarations(atRule, declNodes, isFollowingNestedNode(rule, atRule));
-      atRule.remove();
-      for (const node of nested) {
-        stampSource(node, atRule.source);
-        rule.append(node);
-      }
+      };
     }
   };
 };
 navePlugin.postcss = true;
+var postcss_default = navePlugin;
 
-export { navePlugin };
+export { postcss_default as default, navePlugin };