@jesscss/less-parser 2.0.0-alpha.6 → 2.0.0-alpha.8

package/src/utils.ts

@@ -0,0 +1,178 @@
+import {
+  InterpolatedSelector,
+  Interpolated,
+  Quoted,
+  Reference,
+  INTERPOLATION_PLACEHOLDER,
+  isNode,
+  N,
+  type Selector
+} from '@jesscss/core';
+
+// Pre-compiled regex for @{variable} interpolation - more efficient than creating new instances
+const INTERPOLATION_REGEX = /([$@])\{([^}]+)\}/g;
+
+export const createInterpolatedReference = (
+  prefix: string,
+  varName: string,
+  location?: any,
+  context?: any
+): Reference => {
+  const isProperty = prefix === '$';
+  const key = isProperty
+    ? new Quoted(varName, { quote: '\'' }, location)
+    : varName;
+  return new Reference(
+    { key },
+    { type: isProperty ? 'index' : 'variable', role: 'ident' },
+    location
+  );
+};
+
+export const getInterpolatedNode = (
+  name: string,
+  location?: any,
+  context?: any
+): Interpolated => {
+  const replacements: any[] = [];
+  let source = name;
+  let result;
+
+  INTERPOLATION_REGEX.lastIndex = 0;
+  while ((result = INTERPOLATION_REGEX.exec(name)) !== null) {
+    const [match, prefix, varName] = result;
+    source = source.replace(match, INTERPOLATION_PLACEHOLDER);
+    replacements.push(createInterpolatedReference(prefix ?? '', varName ?? '', location, context));
+  }
+
+  return new Interpolated({ source, replacements }, { role: 'ident' }, location);
+};
+
+export const normalizeMixinReferenceKey = (selector: Selector): { key: string | string[]; rawKey: Selector } => {
+  if (isNode(selector, N.BasicSelector) || selector instanceof InterpolatedSelector) {
+    return { key: selector.valueOf(), rawKey: selector };
+  }
+
+  if (isNode(selector, N.CompoundSelector)) {
+    return {
+      key: selector.value.map(node => node.valueOf()),
+      rawKey: selector
+    };
+  }
+
+  if (isNode(selector, N.ComplexSelector)) {
+    const path: string[] = [];
+    let canUsePath = true;
+
+    for (const node of selector.value) {
+      if (isNode(node, N.BasicSelector) || node instanceof InterpolatedSelector) {
+        path.push(node.valueOf());
+        continue;
+      }
+      if (isNode(node, N.CompoundSelector)) {
+        path.push(...node.value.map(child => child.valueOf()));
+        continue;
+      }
+      if (isNode(node, N.Combinator) && (node.value === '>' || node.value === ' ')) {
+        continue;
+      }
+      canUsePath = false;
+      break;
+    }
+
+    if (canUsePath && path.length > 0) {
+      return { key: path, rawKey: selector };
+    }
+  }
+
+  return { key: selector.valueOf(), rawKey: selector };
+};
+
+/* Handle both @{variable} interpolation and @id-@num variable variables */
+export const getInterpolatedOrString = (name: string, location?: any, context?: any): Interpolated | string => {
+  // First check for @{variable} interpolation syntax
+  const matches: Array<{ fullMatch: string; prefix: string; varName: string; index: number }> = [];
+
+  // Reset regex state and collect all matches
+  INTERPOLATION_REGEX.lastIndex = 0;
+  let result;
+  while ((result = INTERPOLATION_REGEX.exec(name)) !== null) {
+    const [fullMatch, prefix, varName] = result;
+    if (varName && prefix) {
+      matches.push({
+        fullMatch,
+        prefix,
+        varName,
+        index: result.index
+      });
+    }
+  }
+
+  if (matches.length > 0) {
+    // Build source string and replacements
+    let source = name;
+    const replacements: any[] = [];
+    let offset = 0; // Track how much the string has been modified
+
+    // Process matches in forward order to maintain correct indices
+    for (let i = 0; i < matches.length; i++) {
+      const match = matches[i]!;
+      const adjustedIndex = match.index - offset;
+      const beforeMatch = source.substring(0, adjustedIndex);
+      const afterMatch = source.substring(adjustedIndex + match.fullMatch.length);
+
+      source = beforeMatch + INTERPOLATION_PLACEHOLDER + afterMatch;
+      offset += match.fullMatch.length - INTERPOLATION_PLACEHOLDER.length;
+
+      const ref = createInterpolatedReference(match.prefix, match.varName, location, context);
+      replacements.push(ref); // Add to end to maintain order
+    }
+
+    return new Interpolated({ source, replacements }, { role: 'ident' }, location);
+  }
+
+  // If no interpolation found, check for @id-@num variable variables
+  const atPos = name.indexOf('@', 1);
+  const dollarPos = name.indexOf('$', 1);
+
+  if (atPos === -1 && dollarPos === -1) {
+    if (name.startsWith('@') || name.startsWith('$')) {
+      return name.slice(1);
+    } else {
+      return name;
+    }
+  }
+
+  const nextPos = atPos !== -1 ? atPos : dollarPos;
+  const start = name.slice(1, nextPos);
+  const end = name.slice(nextPos);
+  const type: 'variable' | 'index' = end.startsWith('@') ? 'variable' : 'index';
+  // For @id-@num variable variables, we need to create an Interpolated node
+  const endResult = getInterpolatedOrString(end, location, context);
+  if (typeof endResult === 'string') {
+    const endKey = type === 'index'
+      ? new Quoted(endResult, { quote: '\'' }, location)
+      : endResult;
+    return new Interpolated({
+      source: start + INTERPOLATION_PLACEHOLDER,
+      replacements: [
+        new Reference(
+          { key: endKey },
+          { type, role: 'ident' },
+          location
+        )
+      ]
+    }, { role: 'ident' });
+  } else {
+    /**
+     * endResult is already an Interpolated node, so we need to handle this
+     * differently.
+     *
+     * @todo - test deep nesting
+     */
+    return new Interpolated({
+      source: start + INTERPOLATION_PLACEHOLDER,
+      replacements: [type === 'index' ? new Quoted(endResult, { quote: '\'' }, location) : endResult]
+    }, { role: 'ident' });
+  }
+};

package/lib/index.d.cts

@@ -1,150 +0,0 @@
-import { CssRecursiveParser, CssRecursiveParserConfig, CssTokenType, RawModeConfig, RuleContext as RuleContext$1, TokenNames } from "@jesscss/css-parser";
-import { IToken, Lexer, TokenType } from "chevrotain";
-import { ComplexSelector, Extend, IParseResult, MathMode, Node, Rules, Selector, TreeContext } from "@jesscss/core";
-
-//#region src/lessTokens.d.ts
-/**
- * Less-specific token names introduced by merges below
- *
- * @todo - Can't we infer this from the tokens?
- */
-type LessExtraTokenType = 'Ellipsis' | 'AtKeywordLessExtension' | 'Interpolated' | 'LineComment' | 'PlusAssign' | 'UnderscoreAssign' | 'AnonMixinStart' | 'GtEqAlias' | 'LtEqAlias' | 'Extend' | 'AmpersandExtend' | 'AmpersandLParen' | 'AmpersandTemplateContents' | 'AmpersandTemplateEnd' | 'AllFlag' | 'When' | 'WhenFunctionStart' | 'VarOrProp' | 'NestedReference' | 'PropertyReference' | 'Percent' | 'FormatFunction' | 'IfFunction' | 'BooleanFunction' | 'DefaultGuardIdent' | 'DefaultGuardFunc' | 'JavaScript' | 'InterpolatedIdent' | 'InterpolatedCustomProperty' | 'InterpolatedSelector';
-declare function $preBuildTokens(): {
-  modes: any;
-  defaultMode: "Default";
-};
-declare const Fragments: string[][];
-declare const Tokens: {
-  modes: any;
-  defaultMode: "Default";
-};
-type ReturnTokens = ReturnType<typeof $preBuildTokens>;
-type TokenModes = ReturnTokens['modes'];
-type LessTokenType = TokenNames<TokenModes[keyof TokenModes]>;
-declare const lessFragments: () => ReadonlyArray<Readonly<[string, string]>>;
-declare const lessTokens: () => RawModeConfig;
-//#endregion
-//#region src/lessRecursiveParser.d.ts
-type LessParserConfig = CssRecursiveParserConfig & {
-  /**
-   * Is less strict with certain CSS rules and Less syntax
-   * that the old Less parser allowed.
-   *
-   * @note This will also enable CSS legacyMode unless
-   * legacyMode is explicitly false.
-   */
-  looseMode?: boolean;
-  /**
-   * Controls whether mixins and detached rulesets "leak" their inner rules.
-   * When true (default):
-   * - Mixins: Mixin and VarDeclaration nodes are 'public' and 'optional' respectively
-   * - Detached rulesets: Mixin and VarDeclaration nodes are 'public' and 'private' respectively
-   * When false:
-   * - Both mixins and detached rulesets: Mixin and VarDeclaration nodes are 'private'
-   */
-  leakyRules?: boolean;
-  /**
-   * Less math evaluation mode. Used during parsing to decide whether a given
-   * `Operation` should be represented as an `Expression` for Less→Jess conversion.
-   *
-   * Mirrors runtime behavior in `Context.shouldOperate()`.
-   *
-   * @default 'parens-division'
-   */
-  mathMode?: MathMode;
-  /**
-   * When enabled (default), the parser will wrap the *outermost* Less math/value
-   * expressions (math operations, variable references, and chained mixin/variable
-   * calls) in an `Expression({ parens: true })`.
-   *
-   * This is purely a parse-time AST shape choice to support Less→Jess conversion.
-   *
-   * @default true
-   */
-  wrapOuterExpressions?: boolean;
-};
-type CombinedTokenMap = Record<CssTokenType, TokenType> & Record<LessExtraTokenType, TokenType>;
-type TokenMap = CombinedTokenMap;
-interface ExtendTarget {
-  selector?: Selector;
-  target: Selector;
-  flag: IToken | undefined;
-}
-type RuleContext = RuleContext$1 & {
-  selector?: Selector;
-  hasDefault?: boolean;
-  allExtended?: boolean;
-  isDefinition?: boolean;
-  allowAnonymousMixins?: boolean;
-  requireAccessorsAfterMixinCall?: boolean;
-  inValueList?: boolean;
-  allowComma?: boolean;
-  node?: Node;
-  ruleIsFinished?: boolean;
-  sequences?: Array<ComplexSelector | Extend>;
-  asReference?: boolean;
-  extendTargets?: ExtendTarget[];
-  extendNodes?: Extend[];
-  inExtend?: boolean;
-  wrapInExpression?: boolean;
-  parenFrames?: boolean[];
-  calcFrames?: number;
-  detachedRulesetUsage?: 'function-arg' | 'mixin-arg' | 'default-param';
-  inFunctionArgs?: boolean;
-  allowMixinCallWithoutAccessor?: boolean;
-  startValue?: Node;
-};
-declare class LessRecursiveParser extends CssRecursiveParser {
-  T: TokenMap;
-  looseMode: boolean;
-  leakyRules: boolean;
-  /** Warnings collected during parsing */
-  warnings: Array<{
-    message: string;
-    token?: IToken;
-    deprecation?: string;
-  }>;
-  /** See `LessParserConfig.mathMode` */
-  mathMode: MathMode;
-  /** See `LessParserConfig.wrapOuterExpressions` */
-  wrapOuterExpressions: boolean;
-  constructor(T: TokenMap, config?: LessParserConfig);
-  protected processValueToken(token: IToken, ctx?: RuleContext): Node;
-  shouldTryQualifiedRuleInDeclarationList(): boolean;
-  warnDeprecation(message: string, token?: IToken, deprecationId?: string): void;
-}
-//#endregion
-//#region src/lessParser.d.ts
-type LessRules = keyof { [K in keyof LessRecursiveParser as LessRecursiveParser[K] extends ((...args: any[]) => Node) ? K : never]: true };
-type SyntacticContentAssistSuggestion = {
-  nextTokenType: string;
-  nextTokenLabel?: string;
-  ruleStack: string[];
-};
-/**
- * Less parser using the new recursive-descent engine.
- * Keeps Chevrotain's lexer, replaces the parser.
- */
-declare class LessParser {
-  lexer: Lexer;
-  parser: LessRecursiveParser;
-  constructor(config?: LessParserConfig);
-  parse(text: string): IParseResult<Rules>;
-  parse(text: string, rule: 'stylesheet'): IParseResult<Rules>;
-  parse(text: string, rule: 'stylesheet', options: {
-    context?: TreeContext;
-  }): IParseResult<Rules>;
-  parse(text: string, rule?: LessRules, options?: {
-    context?: TreeContext;
-  }): IParseResult;
-  /**
-   * @todo Implement content assist for the new parser
-   */
-  suggest(text: string, init: {
-    offset: number;
-    rule?: LessRules;
-  }): SyntacticContentAssistSuggestion[];
-}
-//#endregion
-export { CombinedTokenMap, ExtendTarget, Fragments, LessExtraTokenType, LessParser, LessParser as Parser, LessParserConfig, LessRecursiveParser, LessRules, LessTokenType, RuleContext, SyntacticContentAssistSuggestion, TokenMap, Tokens, lessFragments, lessTokens };
-//# sourceMappingURL=index.d.cts.map

package/lib/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/lessTokens.ts","../src/lessRecursiveParser.ts","../src/lessParser.ts"],"mappings":";;;;;;;;;AAqBA;KAAY,kBAAA;AAAA,iBAwCH,eAAA,CAAA;EAAe,KAAA;EAAA,WAAA;AAAA;AAAA,cA4RX,SAAA;AAAA,cACA,MAAA;EAA2B,KAAA;EAAA,WAAA;AAAA;AAAA,KAEnC,YAAA,GAAe,UAAA,QAAkB,eAAA;AAAA,KACjC,UAAA,GAAa,YAAA;AAAA,KAEN,aAAA,GAAgB,UAAA,CAAW,UAAA,OAAiB,UAAA;AAAA,cAE3C,aAAA,QAA8C,aAAA,CAAc,QAAA;AAAA,cAC5D,UAAA,QAAwC,aAAA;;;KClUzC,gBAAA,GAAmB,wBAAA;EDXnB;;;;;AA8Be;;ECXzB,SAAA;EDqBsB;;AA4RxB;;;;;AACA;ECxSE,UAAA;;;;ADwSuC;;;;;EC9RvC,QAAA,GAAW,QAAA;EDiSE;;;;AAEf;;;;;ECxRE,oBAAA;AAAA;AAAA,KAIU,gBAAA,GAAmB,MAAA,CAAO,YAAA,EAAc,SAAA,IAAa,MAAA,CAAO,kBAAA,EAAoB,SAAA;AAAA,KAChF,QAAA,GAAW,gBAAA;AAAA,UAEN,YAAA;EACf,QAAA,GAAW,QAAA;EACX,MAAA,EAAQ,QAAA;EACR,IAAA,EAAM,MAAA;AAAA;AAAA,KAGI,WAAA,GAAc,aAAA;EACxB,QAAA,GAAW,QAAA;EACX,UAAA;EACA,WAAA;EACA,YAAA;EACA,oBAAA;EACA,8BAAA;EACA,WAAA;EACA,UAAA;EACA,IAAA,GAAO,IAAA;EACP,cAAA;EACA,SAAA,GAAY,KAAA,CAAM,eAAA,GAAkB,MAAA;EACpC,WAAA;EACA,aAAA,GAAgB,YAAA;EAChB,WAAA,GAAc,MAAA;EACd,QAAA;EACA,gBAAA;EACA,WAAA;EACA,UAAA;EACA,oBAAA;EACA,cAAA;EACA,6BAAA;EACA,UAAA,GAAa,IAAA;AAAA;AAAA,cAGF,mBAAA,SAA4B,kBAAA;EAC/B,CAAA,EAAG,QAAA;EACX,SAAA;EACA,UAAA;EArCkD;EAuClD,QAAA,EAAU,KAAA;IAAQ,OAAA;IAAiB,KAAA,GAAQ,MAAA;IAAQ,WAAA;EAAA;EAvCkB;EA0CrE,QAAA,EAAU,QAAA;EA1C0B;EA4CpC,oBAAA;cAGE,CAAA,EAAG,QAAA,EACH,MAAA,GAAQ,gBAAA;EAAA,UAqCS,iBAAA,CAAkB,KAAA,EAAO,MAAA,EAAQ,GAAA,GAAM,WAAA,GAAc,IAAA;EAqD/D,uCAAA,CAAA;EAmDT,eAAA,CAAgB,OAAA,UAAiB,KAAA,GAAQ,MAAA,EAAQ,aAAA;AAAA;;;KClQvC,SAAA,uBACE,mBAAA,IAAuB,mBAAA,CAAoB,CAAA,eAAe,IAAA,YAAgB,IAAA,IAAO,CAAA;AAAA,KAGnF,gCAAA;EACV,aAAA;EACA,cAAA;EACA,SAAA;AAAA;;;;;cA8CW,UAAA;EACX,KAAA,EAAO,KAAA;EACP,MAAA,EAAQ,mBAAA;cAGN,MAAA,GAAQ,gBAAA;EAYV,KAAA,CAAM,IAAA,WAAe,YAAA,CAAa,KAAA;EAClC,KAAA,CAAM,IAAA,UAAc,IAAA,iBAAqB,YAAA,CAAa,KAAA;EACtD,KAAA,CAAM,IAAA,UAAc,IAAA,gBAAoB,OAAA;IAAW,OAAA,GAAU,WAAA;EAAA,IAAgB,YAAA,CAAa,KAAA;EAC1F,KAAA,CAAM,IAAA,UAAc,IAAA,GAAO,SAAA,EAAW,OAAA;IAAY,OAAA,GAAU,WAAA;EAAA,IAAgB,YAAA;;;;EA4B5E,OAAA,CAAQ,IAAA,UAAc,IAAA;IAAQ,MAAA;IAAgB,IAAA,GAAO,SAAA;EAAA,IAAc,gCAAA;AAAA"}