@jesscss/css-parser 1.0.6-alpha.0 → 2.0.0-alpha.1

package/lib/advancedActionsParser.d.ts

@@ -0,0 +1,60 @@
+import { EmbeddedActionsParser, type IParserConfig, type TokenVocabulary, type IToken, type SubruleMethodOpts } from 'chevrotain';
+type ParserMethodInternal<ARGS extends any[] = any[], R = any> = ((...args: ARGS) => R) & {
+    ruleName: string;
+};
+import { TreeContext, type LocationInfo } from '@jesscss/core';
+/** Apply this label to tokens you wish to skip during parsing consideration */
+export declare const SKIPPED_LABEL = "Skipped";
+/** The name of the whitespace token */
+export declare const WS_NAME = "WS";
+/**
+ * @note copied from 'chevrotain/src/parse/grammar/keys'
+ * We have to copy these because they aren't exported
+ */
+export declare const BITS_FOR_OCCURRENCE_IDX = 8;
+export declare const OR_IDX: number;
+export declare const OPTION_IDX: number;
+/**
+ * A parser that can make decisions based on whitespace,
+ * yet doesn't _require_ parsing whitespace in the main
+ * token stream.
+ */
+export declare class AdvancedActionsParser extends EmbeddedActionsParser {
+    /** Indexed by the startOffset of the next token it precedes */
+    preSkippedTokenMap: Map<number, IToken[]>;
+    postSkippedTokenMap: Map<number, IToken[]>;
+    /** Boolean flag for used in post node */
+    usedSkippedTokens: Set<IToken[]>;
+    _context: TreeContext | undefined;
+    locationStack: LocationInfo[];
+    originalInput: IToken[];
+    /** Exposed from Chevrotain */
+    currIdx: number;
+    get context(): TreeContext;
+    set context(c: TreeContext);
+    subruleInternal: <ARGS extends unknown[], R>(ruleToCall: ParserMethodInternal<ARGS, R>, idx: number, options?: SubruleMethodOpts<ARGS>) => R;
+    getKeyForAutomaticLookahead: (dslMethodIdx: number, occurrence: number) => number;
+    raiseNoAltException: (occurrence: number, errMsgTypes: string | undefined) => never;
+    getLaFuncFromCache: (key: number) => (...args: any[]) => any;
+    constructor(tokenVocabulary: TokenVocabulary, config: IParserConfig);
+    /** Separate skipped tokens into a new map */
+    set input(value: IToken[]);
+    _subruleInternal<ARGS extends unknown[], R>(ruleToCall: ParserMethodInternal<ARGS, R>, idx: number, options?: SubruleMethodOpts<ARGS>): R;
+    /**
+     * Used in a GATE.
+     * Determine if there is white-space before the next token
+     */
+    hasWS(): boolean;
+    /**
+     * Used in a GATE.
+     * Affirms that there is NOT white space or comment before next token
+     */
+    noSep(offset?: number): boolean;
+    protected startRule(): LocationInfo | undefined;
+    /** Should only be called when not in recording phase */
+    protected endRule(): LocationInfo;
+    /** @note might not need these */
+    protected getLocationInfo(loc: IToken): LocationInfo;
+    protected isToken(node: any): node is IToken;
+}
+export {};

package/lib/advancedActionsParser.js

@@ -0,0 +1,203 @@
+import { EmbeddedActionsParser, EOF
+// type IOrAlt,
+// type OrMethodOpts
+ } from 'chevrotain';
+import { TreeContext } from '@jesscss/core';
+/** Apply this label to tokens you wish to skip during parsing consideration */
+export const SKIPPED_LABEL = 'Skipped';
+/** The name of the whitespace token */
+export const WS_NAME = 'WS';
+// const { isArray } = Array
+/**
+ * @note copied from 'chevrotain/src/parse/grammar/keys'
+ * We have to copy these because they aren't exported
+ */
+export const BITS_FOR_OCCURRENCE_IDX = 8;
+export const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
+export const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
+/**
+ * A parser that can make decisions based on whitespace,
+ * yet doesn't _require_ parsing whitespace in the main
+ * token stream.
+ */
+export class AdvancedActionsParser extends EmbeddedActionsParser {
+    /** Indexed by the startOffset of the next token it precedes */
+    preSkippedTokenMap;
+    postSkippedTokenMap;
+    /** Boolean flag for used in post node */
+    usedSkippedTokens;
+    _context;
+    locationStack = [];
+    // captureStack: number[]
+    originalInput;
+    get context() {
+        return (this._context ??= new TreeContext());
+    }
+    set context(c) {
+        this._context = c;
+    }
+    constructor(tokenVocabulary, config) {
+        super(tokenVocabulary, config);
+        if (!config.skipValidations) {
+            this.subruleInternal = this._subruleInternal.bind(this);
+        }
+    }
+    /** Separate skipped tokens into a new map */
+    set input(value) {
+        const preSkippedTokenMap = this.preSkippedTokenMap = new Map();
+        const postSkippedTokenMap = this.postSkippedTokenMap = new Map();
+        const inputTokens = [];
+        let valueLength = value.length;
+        let prevToken;
+        const isSkippedToken = (t) => {
+            if (!t) {
+                return false;
+            }
+            const name = t.tokenType.name;
+            return t.tokenType.LABEL === SKIPPED_LABEL || name === WS_NAME || /Comment/i.test(name);
+        };
+        for (let i = 0; i < valueLength; i++) {
+            const token = value[i];
+            let nextToken = undefined;
+            /** Find the next non-skipped token; if none found, leave as undefined */
+            for (let j = i + 1; j < valueLength; j++) {
+                const candidate = value[j];
+                if (!isSkippedToken(candidate)) {
+                    nextToken = candidate;
+                    break;
+                }
+            }
+            const beforeIndex = nextToken?.startOffset ?? Infinity;
+            const tokName = token.tokenType.name;
+            const currIsSkipped = isSkippedToken(token);
+            // removed diagnostics
+            if (currIsSkipped) {
+                let tokens = preSkippedTokenMap.get(beforeIndex);
+                if (tokens) {
+                    tokens.push(token);
+                }
+                else {
+                    tokens = [token];
+                    preSkippedTokenMap.set(beforeIndex, tokens);
+                }
+                if (prevToken) {
+                    postSkippedTokenMap.set(prevToken.endOffset, tokens);
+                }
+            }
+            else {
+                prevToken = token;
+                inputTokens.push(token);
+            }
+        }
+        this.usedSkippedTokens = new Set();
+        // removed diagnostics
+        this.originalInput = value;
+        super.input = inputTokens;
+    }
+    _subruleInternal(ruleToCall, idx, options) {
+        let name = ruleToCall.ruleName;
+        let preLength = this.locationStack.length;
+        // @ts-expect-error - This exists
+        let result = super.subruleInternal(ruleToCall, idx, options);
+        let postLength = this.locationStack.length;
+        if (postLength !== preLength) {
+            /**
+             * In recovery-enabled parses (linting / language services), a rule may
+             * throw before reaching its explicit `endRule()` call. That should be a
+             * parse error, not a fatal runtime error.
+             *
+             * Keep the invariant check in non-recovery mode (to catch authoring bugs),
+             * but unwind the stack in recovery mode so parsing can continue.
+             */
+            if (this.recoveryEnabled) {
+                while (this.locationStack.length > preLength) {
+                    this.locationStack.pop();
+                }
+            }
+            else {
+                throw new Error(`Rule ${name} did not call endRule()`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Used in a GATE.
+     * Determine if there is white-space before the next token
+     */
+    hasWS() {
+        let startOffset = this.LA(1).startOffset;
+        const skipped = this.preSkippedTokenMap.get(startOffset);
+        if (!skipped) {
+            return false;
+        }
+        return !!skipped.find(token => token.tokenType.name === WS_NAME);
+    }
+    /**
+     * Used in a GATE.
+     * Affirms that there is NOT white space or comment before next token
+     */
+    noSep(offset = 0) {
+        let startOffset = this.LA(1 + offset).startOffset;
+        return !this.preSkippedTokenMap.get(startOffset);
+    }
+    startRule() {
+        if (!this.RECORDING_PHASE) {
+            let { startOffset, startLine, startColumn } = this.LA(1);
+            let location = [startOffset, startLine, startColumn, NaN, NaN, NaN];
+            this.locationStack.push(location);
+            return location;
+        }
+    }
+    /** Should only be called when not in recording phase */
+    endRule() {
+        let { endOffset, endLine, endColumn } = this.LA(0);
+        let location = this.locationStack.pop();
+        location[3] = endOffset;
+        location[4] = endLine;
+        location[5] = endColumn;
+        return location;
+    }
+    /** @note might not need these */
+    // protected startCapture() {
+    //   if (!this.RECORDING_PHASE) {
+    //     let idx = this.currIdx
+    //     this.startRule()
+    //     this.captureStack.push(idx)
+    //   }
+    // }
+    // protected endCapture(): [string, LocationInfo] {
+    //   let location = this.endRule()
+    //   let prevIdx = this.captureStack.pop()!
+    //   let currIdx = this.currIdx
+    //   let input = this.originalInput
+    //   let tokenStr = ''
+    //   let token: IToken | undefined
+    //   for (let i = prevIdx; i <= currIdx; i++) {
+    //     token = input[i]!
+    //     if (this.preSkippedTokenMap.has(token.startOffset)) {
+    //       for (let skipped of this.preSkippedTokenMap.get(token.startOffset)!) {
+    //         tokenStr += skipped.image
+    //       }
+    //     }
+    //     tokenStr += token.image
+    //   }
+    //   if (token && this.postSkippedTokenMap.has(token.endOffset!)) {
+    //     for (let skipped of this.postSkippedTokenMap.get(token.endOffset!)!) {
+    //       tokenStr += skipped.image
+    //     }
+    //   }
+    //   return [tokenStr, location]
+    // }
+    getLocationInfo(loc) {
+        if (loc.tokenType === EOF) {
+            return new Array(6).fill(Infinity);
+        }
+        const { startOffset, startLine, startColumn, endOffset, endLine, endColumn } = loc;
+        /** Assert that, in our case, tokens will have these properties */
+        return [startOffset, startLine, startColumn, endOffset, endLine, endColumn];
+    }
+    isToken(node) {
+        return Boolean(node && 'tokenType' in node);
+    }
+}
+//# sourceMappingURL=advancedActionsParser.js.map

package/lib/advancedActionsParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advancedActionsParser.js","sourceRoot":"","sources":["../src/advancedActionsParser.ts"],"names":[],"mappings":"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"}

package/lib/cssActionsParser.d.ts

@@ -0,0 +1,155 @@
+import { type TokenVocabulary, type TokenType, type IParserConfig, type ParserMethod, type IToken, type IRecognitionException } from 'chevrotain';
+import { AdvancedActionsParser } from './advancedActionsParser.js';
+import { type CssTokenType } from './cssTokens.js';
+import { type LocationInfo, Node, Rules } from '@jesscss/core';
+export type TokenMap = Record<CssTokenType, TokenType>;
+export type Rule<F extends (...args: any[]) => void = (ctx?: RuleContext) => void> = ParserMethod<Parameters<F>, any>;
+export interface CssParserConfig extends IParserConfig {
+    /** Things like star property hacks and IE filters */
+    legacyMode?: boolean;
+}
+export type RuleContext = {
+    /** Inside a declaration list */
+    inner?: boolean;
+    /** Determine if this is the first selector in the list */
+    firstSelector?: boolean;
+    /** If downstream selector rules are part of a qualified rule */
+    qualifiedRule?: boolean;
+    /** Inside a custom property value */
+    inCustomPropertyValue?: boolean;
+    [k: string]: object | boolean | string | object[] | number | undefined;
+};
+/**
+ * @note - we use an EmbeddedActionsParser for a few reasons:
+ *   1. Jess's AST is essentially a CST; that is, it records
+ *      all whitespace and comments. (The one difference may
+ *      be that some nodes are "simplified" in the Jess AST.)
+ *   2. Chevrotain's CST is not the most efficient structure
+ *      for a CST.
+ *   3. We can avoid the overhead of a CST visitor by creating
+ *      the Jess nodes directly.
+ *   4. In some cases, we need some additional business logic
+ *      about what the intended structure of the AST is, based
+ *      on the presence of certain tokens.
+ */
+export declare class CssActionsParser extends AdvancedActionsParser {
+    T: TokenMap;
+    legacyMode: boolean;
+    ruleIndex: number;
+    _errors: Array<IRecognitionException>;
+    /** Expose Chevrotain's flag */
+    skipValidations: boolean;
+    /** Rewire, declaring class fields in constructor with `public` */
+    stylesheet: Rule<(options?: Record<string, any>) => void>;
+    main: Rule;
+    qualifiedRule: Rule;
+    atRule: Rule;
+    selectorList: Rule;
+    declarationList: Rule;
+    forgivingSelectorList: Rule;
+    classSelector: Rule;
+    idSelector: Rule;
+    pseudoSelector: Rule;
+    attributeSelector: Rule;
+    nthValue: Rule;
+    complexSelector: Rule;
+    simpleSelector: Rule;
+    compoundSelector: Rule;
+    relativeSelector: Rule;
+    declaration: Rule;
+    valueList: Rule;
+    /** Often a space-separated sequence */
+    valueSequence: Rule;
+    value: Rule;
+    squareValue: Rule;
+    customValue: Rule;
+    innerCustomValue: Rule;
+    functionCall: Rule;
+    functionCallLike: Rule;
+    functionCallArgs: Rule;
+    ifFunction: Rule;
+    ifFunctionArgs: Rule;
+    knownFunctions: Rule;
+    varFunction: Rule;
+    calcFunction: Rule;
+    urlFunction: Rule;
+    unknownValue: Rule;
+    string: Rule;
+    mathSum: Rule;
+    mathProduct: Rule;
+    mathValue: Rule;
+    mathParen: Rule;
+    /** At Rules */
+    innerAtRule: Rule;
+    importAtRule: Rule;
+    importPrelude: Rule;
+    importPostlude: Rule;
+    mediaAtRule: Rule;
+    supportsAtRule: Rule;
+    containerAtRule: Rule;
+    containerName: Rule;
+    containerQueryList: Rule;
+    containerQuery: Rule;
+    containerCondition: Rule;
+    containerInParens: Rule;
+    containerFeature: Rule;
+    containerAnd: Rule;
+    containerOr: Rule;
+    atRuleBody: Rule;
+    pageAtRule: Rule;
+    keyframesAtRule: Rule;
+    keyframesName: Rule;
+    layerAtRule: Rule;
+    layerName: Rule;
+    scopeAtRule: Rule;
+    documentAtRule: Rule;
+    pageSelector: Rule;
+    fontFaceAtRule: Rule;
+    nestedAtRule: Rule;
+    nonNestedAtRule: Rule;
+    unknownAtRule: Rule;
+    /** `@media` syntax */
+    mediaQueryList: Rule;
+    mediaQuery: Rule;
+    mediaCondition: Rule;
+    mediaType: Rule;
+    mediaConditionWithoutOr: Rule;
+    mediaNot: Rule;
+    mediaInParens: Rule;
+    mediaAnd: Rule;
+    mediaOr: Rule;
+    mediaFeature: Rule;
+    mfValue: Rule;
+    mediaRange: Rule;
+    mfComparison: Rule;
+    mfNonIdentifierValue: Rule;
+    /** `@container` syntax - declarations are above */
+    /**
+     * `@supports` syntax - the parsing is defined differently
+     * from `@media`, which is fortunate, because it's much
+     * simpler.
+    */
+    supportsCondition: Rule;
+    supportsInParens: Rule;
+    /** General purpose subrules */
+    anyOuterValue: Rule;
+    anyInnerValue: Rule;
+    extraTokens: Rule;
+    customBlock: Rule;
+    constructor(tokenVocabulary: TokenVocabulary, T: TokenMap, config?: CssParserConfig);
+    set input(value: IToken[]);
+    protected getLocationFromNodes(nodes: Array<IToken | Node>): LocationInfo | undefined;
+    protected getRulesWithComments(existingRules?: Node[], nextTokenLocation?: LocationInfo): Rules;
+    protected getPrePost(offset: number, post?: boolean, ctx?: RuleContext): Node['pre'];
+    /**
+     * Attaches pre / post whitespace and comments.
+     * Note that nodes can be wrapped more than once.
+     *
+     * @note Some nodes can't be wrapped because they
+     * don't represent a location. For instance, a
+     * Rules node may be empty, and hence doesn't
+     * have a location.
+     */
+    protected wrap<T extends Node = Node>(node: T, post?: boolean | 'both', ctx?: RuleContext): T;
+    protected processValueToken(token: IToken, _ctx?: RuleContext): Node;
+}