@jesscss/scss-parser 2.0.0-alpha.8 → 2.0.0-alpha.9

package/src/interp.ts

@@ -1,158 +0,0 @@
-/**
- * SCSS `#{…}` interpolation helpers for the functional grammar builders.
- * Mirrors productions/helpers.ts (Chevrotain) without the nested parser bootstrap.
- */
-import {
-  Any,
-  Expression,
-  Interpolated,
-  INTERPOLATION_PLACEHOLDER,
-  Reference,
-  isNode,
-  N,
-  Node,
-  type LocationInfo
-} from '@jesscss/core';
-
-export type InterpRole = 'ident' | 'property' | 'any' | 'name';
-
-let parseScssFnLazy: ((input: string, rule?: string) => import('./grammar.js').ScssFnParseResult) | undefined;
-
-/** Wired from grammar.ts after `parseScssFn` is defined (breaks circular import). */
-export function setParseScssFnForInterp(
-  fn: (input: string, rule?: string) => import('./grammar.js').ScssFnParseResult
-): void {
-  parseScssFnLazy = fn;
-}
-
-export function findScssInterpolationSpans(value: string): Array<{ start: number; end: number; content: string }> {
-  const matches: Array<{ start: number; end: number; content: string }> = [];
-  let i = 0;
-  while (i < value.length) {
-    if (value[i] === '#' && value[i + 1] === '{') {
-      const start = i;
-      i += 2;
-      let depth = 1;
-      const contentStart = i;
-      while (i < value.length && depth > 0) {
-        const ch = value[i]!;
-        if (ch === '{') {
-          depth++;
-        } else if (ch === '}') {
-          depth--;
-        }
-        i++;
-      }
-      if (depth === 0) {
-        matches.push({ start, end: i, content: value.slice(contentStart, i - 1) });
-      }
-    } else {
-      i++;
-    }
-  }
-  return matches;
-}
-
-function unwrapSingleReference(n: Node): Reference | undefined {
-  if (
-    isNode(n, N.Reference)
-    && n.options?.type === 'variable'
-    && !n.target
-    && typeof n.key === 'string'
-  ) {
-    return n;
-  }
-  return undefined;
-}
-
-function valueFromParseResult(
-  r: import('./grammar.js').ScssFnParseResult,
-  fallback: string,
-  loc: LocationInfo
-): Node {
-  const root = r.tree;
-  if (isNode(root, N.Rules) && root.rules.length > 0) {
-    return root.rules[0]!;
-  }
-  if (root instanceof Node) {
-    return root;
-  }
-  return new Any(fallback, { role: 'any' }, loc);
-}
-
-/** Parse a `#{…}` inner expression via the functional value grammar. */
-export function parseScssInterpExpr(expr: string, loc: LocationInfo): Node {
-  const trimmed = expr.trim();
-  if (!trimmed) {
-    return new Any('', { role: 'any' }, loc);
-  }
-  if (!parseScssFnLazy) {
-    throw new Error('parseScssFn not wired for interpolation (setParseScssFnForInterp)');
-  }
-  const r = parseScssFnLazy(trimmed, 'valueList');
-  if (r.errors.length) {
-    return new Any(trimmed, { role: 'any' }, loc);
-  }
-  const tree = valueFromParseResult(r, trimmed, loc);
-  const ref = unwrapSingleReference(tree);
-  if (ref && typeof ref.key === 'string') {
-    return new Reference({ key: ref.key }, { type: 'variable', role: 'ident' }, loc);
-  }
-  if (isNode(tree, N.Reference)) {
-    return new Expression(tree, undefined, loc);
-  }
-  return tree;
-}
-
-/**
- * Validate a `selector.parse("…")` argument through the functional selector
- * grammar. Returns `true` when the text is a well-formed selector list. Used to
- * gate lifting a `selector.*` call into a `SelectorCapture`; the capture keeps the
- * lean string payload (`SelectorCapture` supports a bare-string `SelectorLike`).
- */
-export function isValidScssSelectorList(selectorText: string): boolean {
-  const trimmed = selectorText.trim();
-  if (!trimmed) {
-    return false;
-  }
-  if (!parseScssFnLazy) {
-    throw new Error('parseScssFn not wired for interpolation (setParseScssFnForInterp)');
-  }
-  const r = parseScssFnLazy(trimmed, 'SelectorList');
-  return r.errors.length === 0;
-}
-
-/** Turn a parsed expression into an interpolation replacement (name/ident slots). */
-export function toInterpReplacement(expr: Node, loc: LocationInfo): Node {
-  const ref = unwrapSingleReference(expr);
-  if (ref && typeof ref.key === 'string') {
-    return new Reference({ key: ref.key }, { type: 'variable', role: 'ident' }, loc);
-  }
-  if (isNode(expr, N.Reference)) {
-    return new Expression(expr, undefined, loc);
-  }
-  return expr;
-}
-
-/** Build an `Interpolated` node from a string containing `#{…}` runs. */
-export function buildScssInterpolatedFromString(
-  value: string,
-  loc: LocationInfo,
-  role: InterpRole
-): Any | Interpolated {
-  const matches = findScssInterpolationSpans(value);
-  if (matches.length === 0) {
-    return new Any(value, { role }, loc);
-  }
-  const replacements: Node[] = [];
-  let source = value;
-  let offset = 0;
-  for (const match of matches) {
-    const adjustedStart = match.start - offset;
-    const adjustedEnd = match.end - offset;
-    source = source.slice(0, adjustedStart) + INTERPOLATION_PLACEHOLDER + source.slice(adjustedEnd);
-    offset += (match.end - match.start) - INTERPOLATION_PLACEHOLDER.length;
-    replacements.push(toInterpReplacement(parseScssInterpExpr(match.content, loc), loc));
-  }
-  return new Interpolated({ source, replacements }, { role }, loc);
-}

package/src/jess.ts

@@ -1,11 +0,0 @@
-export { ScssGrammar } from './builders.js';
-export {
-  ScssParser,
-  ScssParser as Parser,
-  parseScssFn,
-  type ScssFnParseResult,
-  type ScssFnParseOptions,
-  type ScssParserConfig,
-  type ScssRules,
-  type SyntacticContentAssistSuggestion
-} from './functional-parser.js';

package/src/scss-atroot-helpers.ts

@@ -1,105 +0,0 @@
-import {
-  Ampersand,
-  ComplexSelector,
-  isNode,
-  N,
-  Nil,
-  Ruleset,
-  SelectorList,
-  sourceSpanOf,
-  type LocationInfo,
-  type Node,
-  type Rules,
-  type Selector,
-  type TreeContext
-} from '@jesscss/core';
-
-export function createNullParentAmpersand(context?: TreeContext, selector?: Selector): Ampersand {
-  const location = selector ? sourceSpanOf(selector) : undefined;
-  const nil = new Nil(undefined, undefined, location, context);
-  const amp = new Ampersand(
-    { selectorContainer: { selector: nil } },
-    undefined,
-    location,
-    context
-  );
-  amp.adopt(nil);
-  return amp;
-}
-
-function getNodeLocation(node: Node): LocationInfo | undefined {
-  return sourceSpanOf(node);
-}
-
-export function prefixAtRootSelector(selector: Selector, context?: TreeContext): Selector {
-  if (isNode(selector, N.SelectorList)) {
-    const list = selector;
-    return new SelectorList(
-      list.value.map(item => prefixAtRootSelector(item, context)),
-      undefined,
-      getNodeLocation(selector),
-      context
-    );
-  }
-
-  const amp = createNullParentAmpersand(context, selector);
-  if (isNode(selector, N.ComplexSelector)) {
-    const complex = selector;
-    return new ComplexSelector(
-      [amp, ...complex.value],
-      undefined,
-      getNodeLocation(selector),
-      context
-    );
-  }
-
-  return new ComplexSelector([amp, selector], undefined, getNodeLocation(selector), context);
-}
-
-export function lowerPlainAtRootRules(rules: Rules, context?: TreeContext): void {
-  const transformRule = (node: Node): Node => {
-    if (isNode(node, N.Ruleset)) {
-      const rs = node;
-      if (!isNode(rs.selector, N.Nil)) {
-        return new Ruleset({
-          selector: prefixAtRootSelector(rs.selector, context),
-          rules: rs.rules,
-          ...(rs.guard !== undefined && { guard: rs.guard }),
-          ...(rs.selectorBeforeExtend !== undefined && {
-            selectorBeforeExtend: rs.selectorBeforeExtend
-          })
-        }, rs.options, sourceSpanOf(rs), context);
-      }
-      return node;
-    }
-
-    if (isNode(node, N.AtRule) && node.rules) {
-      lowerPlainAtRootRules(node.rules, context);
-      return node;
-    }
-
-    if (isNode(node, N.If)) {
-      lowerPlainAtRootRules(node, context);
-      if (node.else) {
-        lowerPlainAtRootRules(node.else, context);
-      }
-      return node;
-    }
-
-    if (isNode(node, N.For)) {
-      lowerPlainAtRootRules(node, context);
-      return node;
-    }
-
-    if (isNode(node, N.While)) {
-      lowerPlainAtRootRules(node, context);
-      return node;
-    }
-
-    return node;
-  };
-
-  for (let i = 0; i < rules.rules.length; i++) {
-    rules.rules[i] = transformRule(rules.rules[i]!);
-  }
-}

package/src/scss-atrule-helpers.ts

@@ -1,191 +0,0 @@
-/**
- * Shared helpers for SCSS module-system at-rules in the functional parser.
- */
-/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
-import {
-  Any,
-  Quoted,
-  isNode,
-  N,
-  sourceSpanOf,
-  type Node,
-  type LocationInfo,
-  type ExtendSelectorKind,
-  Url
-} from '@jesscss/core';
-
-export function isScriptUsePath(path: string): boolean {
-  return path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.json');
-}
-
-export function defaultNamespaceFromPath(path: string): string | undefined {
-  if (path.startsWith('sass:')) {
-    const name = path.slice('sass:'.length);
-    return name.split('/').filter(Boolean).pop();
-  }
-  const base = path.split('/').filter(Boolean).pop();
-  if (!base) {
-    return undefined;
-  }
-  const noExt = base.replace(/\.(scss|sass|css|jess|js|ts|json)$/i, '');
-  return noExt || undefined;
-}
-
-export function quotedLike(original: Quoted, nextValue: string, loc?: LocationInfo): Quoted {
-  const quote = original.options?.quote ?? '"';
-  const escaped = original.options?.escaped;
-  const nodeLoc: LocationInfo | undefined = loc ?? sourceSpanOf(original);
-  return new Quoted(new Any(nextValue, { role: 'any' }), { quote, escaped }, nodeLoc);
-}
-
-/**
- * Detect the CSS `@import` ordering violations Sass parse-rejects (`error/wrong_order/*`).
- * The full media-query-list / `supports()` grammar is out of scope for the
- * scanned prelude, so this catches the clearly-invalid, low-false-positive
- * shapes on the raw prelude text (everything after `@import`, minus the path):
- *
- *   1. A bare media feature `(x: y)` (NOT a `fn(...)` call — hence the
- *      no-ident-before-`(` guard) followed by anything other than `and` / `or` /
- *      `,` / `;` / end. Catches `"a" (b: c) supports(d: e)`, `"a" (b: c) d`,
- *      `"a" (b: c) d(e)`.
- *   2. A comma directly followed by a function call `ident(` — a new import item
- *      can never be `supports(...)` or an unknown function. Catches
- *      `"a" b, supports(c: d)`, `"a" b, c(d)`, and `"a", url(b)`.
- *
- * Not caught (documented as remaining): a string after a comma in media context
- * (`"a" b, "c"` — indistinguishable from a valid plain-import continuation without
- * modelling media-vs-plain state) and `supports()` value-syntax errors
- * (`supports(--a:)`).
- */
-export function checkImportPreludeOrder(
-  preludeText: string,
-  recordError: (message: string) => void
-): void {
-  const text = preludeText;
-  // A bare media feature may be followed by `and`/`or` (query chain), `,`/`;`
-  // (list / end), `{`/`}` (block bounds), or `)` (closes an enclosing
-  // `supports(...)` / group). Anything else — `supports(`, an ident, a function —
-  // is the wrong-order violation.
-  const badFeatureOrder = /(?<![-\w])\([^()]*:[^()]*\)\s*(?!and(?![-\w])|or(?![-\w])|[,;{})])\S/i;
-  const badCommaFunction = /,\s*[a-zA-Z][-\w]*\s*\(/;
-  if (badFeatureOrder.test(text) || badCommaFunction.test(text)) {
-    recordError('Invalid @import: a media-query list must not follow a media feature without `and`/`or`, and a comma-separated @import item must be a URL or string (not `supports(…)` or another function).');
-  }
-}
-
-export function isPlainCssImportPath(rawPath: string): boolean {
-  return /\.css(?:$|[?#])/i.test(rawPath)
-    || /^[a-z]+:\/\//i.test(rawPath)
-    || rawPath.startsWith('//');
-}
-
-export function isPlainCssImportPrelude(prelude: Node, extraText: string | undefined): boolean {
-  if (prelude instanceof Url) {
-    return true;
-  }
-  if (extraText && extraText.trim()) {
-    return true;
-  }
-  if (isNode(prelude, N.Quoted)) {
-    return isPlainCssImportPath(prelude.valueOf());
-  }
-  return true;
-}
-
-export function findDisallowedExtendSelector(
-  selector: Node,
-  allowed: readonly ExtendSelectorKind[]
-): { kind: ExtendSelectorKind; selector: Node } | undefined {
-  if (isNode(selector, N.SelectorList)) {
-    for (const item of selector.value) {
-      const disallowed = findDisallowedExtendSelector(item as Node, allowed);
-      if (disallowed) {
-        return disallowed;
-      }
-    }
-    return undefined;
-  }
-  const kinds: ExtendSelectorKind[] = isNode(selector, N.BasicSelector)
-    ? ['simple', 'basic']
-    : isNode(selector, N.PseudoSelector)
-      ? ['simple', 'pseudo']
-      : isNode(selector, N.CompoundSelector)
-        ? ['compound']
-        : isNode(selector, N.ComplexSelector)
-          ? ['complex']
-          : ['simple'];
-  if (isNode(selector, N.CompoundSelector) && selector.value.length === 1) {
-    return findDisallowedExtendSelector(selector.value[0] as Node, allowed);
-  }
-  if (isNode(selector, N.ComplexSelector) && selector.value.length === 1) {
-    return findDisallowedExtendSelector(selector.value[0] as Node, allowed);
-  }
-  if (kinds.some(k => allowed.includes(k))) {
-    return undefined;
-  }
-  return { kind: kinds[0]!, selector };
-}
-
-export function validateExtendTarget(
-  target: Node,
-  allowed: readonly ExtendSelectorKind[] | undefined,
-  recordError: (message: string) => void
-): void {
-  if (!allowed) {
-    return;
-  }
-  const disallowed = findDisallowedExtendSelector(target, allowed);
-  if (!disallowed) {
-    return;
-  }
-  const kindList = allowed.length === 1 ? `${allowed[0]} value` : allowed.join(', ');
-  recordError(
-    `@extend only allows ${kindList}, but found ${disallowed.kind} selector "${disallowed.selector.valueOf()}".`
-  );
-}
-
-export function checkForwardPreludeErrors(
-  preludeExtra: string | undefined,
-  recordError: (message: string) => void
-): void {
-  if (!preludeExtra?.trim()) {
-    return;
-  }
-  // Normalize away loud/silent comments and collapse whitespace so a prefix form
-  // interrupted by a comment or newline (`as /**/ a-*`, `as //\n a-*`) still
-  // matches the rejection patterns below.
-  const text = preludeExtra
-    .replace(/\/\*[\s\S]*?\*\//g, ' ')
-    .replace(/\/\/[^\n\r]*/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-  if (/\bas\s+\S+-\*/.test(text)) {
-    recordError(
-      '@forward with "as <prefix>-*" prefixing is not supported in Jess and will never be. Use explicit namespacing instead.'
-    );
-  }
-  if (/\b(show|hide)\b/.test(text)) {
-    recordError(
-      '@forward with "show"/"hide" lists is not supported in Jess and will never be. Visibility control belongs to the module itself.'
-    );
-  }
-}
-
-export function isPlaceholderExtendTarget(target: Node | string): boolean {
-  if (typeof target === 'string') {
-    return target.startsWith('\\');
-  }
-  if (isNode(target, N.BasicSelector)) {
-    return target.value.startsWith('\\');
-  }
-  if (isNode(target, N.SelectorList) && target.value.length === 1) {
-    return isPlaceholderExtendTarget(target.value[0] as Node);
-  }
-  if (isNode(target, N.CompoundSelector) && target.value.length === 1) {
-    return isPlaceholderExtendTarget(target.value[0] as Node);
-  }
-  if (isNode(target, N.ComplexSelector) && target.value.length === 1) {
-    return isPlaceholderExtendTarget(target.value[0] as Node);
-  }
-  return false;
-}

package/src/scss-value-helpers.ts

@@ -1,105 +0,0 @@
-/**
- * SCSS value desugaring helpers for the functional grammar builders.
- * Ports productions/helpers.ts without the Chevrotain parser bootstrap.
- */
-import {
-  Call,
-  Reference,
-  isNode,
-  N,
-  type LocationInfo,
-  type Node
-} from '@jesscss/core';
-
-export function unwrapSingleSequence(n: Node): Node {
-  if (isNode(n, N.Sequence) && n.value.length === 1) {
-    return n.value[0]!;
-  }
-  return n;
-}
-
-export function toDeclKey(node: Node): string {
-  return String(node.valueOf());
-}
-
-export function isValidIdentifierKey(key: string): boolean {
-  return /^[a-zA-Z_-][a-zA-Z0-9_-]*$/.test(key);
-}
-
-export function makeNamespacedReference(
-  parts: string[],
-  finalType: 'variable' | 'function' | 'mixin' | 'mixin-ruleset',
-  loc: LocationInfo
-): Reference {
-  let current: Reference = new Reference(parts[0]!, { type: 'variable' }, loc);
-  for (let i = 1; i < parts.length; i++) {
-    const isFinal = i === parts.length - 1;
-    current = new Reference(
-      { target: current, key: parts[i]! },
-      { type: isFinal ? finalType : 'index' },
-      loc
-    );
-  }
-  return current;
-}
-
-export function desugarNamespacedCall(call: Call, loc: LocationInfo): Call {
-  const { name, args } = call;
-  if (typeof name !== 'string') {
-    return call;
-  }
-  if (!name.includes('.')) {
-    return call;
-  }
-  if (name === 'map.get') {
-    return call;
-  }
-  const parts = name.split('.').filter(Boolean);
-  if (parts.length < 2) {
-    return call;
-  }
-  const ref = makeNamespacedReference(parts, 'function', loc);
-  return new Call({ name: ref, args }, call.options, loc);
-}
-
-export function desugarMapLookup(call: Call, loc: LocationInfo): Node {
-  const { name, args: argsList } = call;
-  if (typeof name !== 'string') {
-    return call;
-  }
-  if (name !== 'map-get' && name !== 'map.get') {
-    return call;
-  }
-
-  const args = isNode(argsList, N.List) ? argsList.value : [];
-  if (args.length < 2) {
-    return call;
-  }
-
-  const mapExpr = unwrapSingleSequence(args[0]!);
-  const keyArgs = args.slice(1).map(a => unwrapSingleSequence(a));
-
-  const initialTarget =
-    isNode(mapExpr, N.Reference)
-      ? mapExpr
-      : isNode(mapExpr, N.Call)
-        ? mapExpr
-        : undefined;
-
-  if (!initialTarget) {
-    return call;
-  }
-
-  let currentTarget: Reference | Call = initialTarget;
-  for (const keyNode of keyArgs) {
-    const keyStr = toDeclKey(keyNode);
-    const useDeclaration = isValidIdentifierKey(keyStr);
-    currentTarget = new Reference(
-      { target: currentTarget, key: useDeclaration ? keyStr : keyNode },
-      { type: useDeclaration ? 'declaration' : 'index' },
-      loc
-    );
-  }
-
-  return currentTarget;
-}