@jesscss/core 2.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Matthew Dean
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# Jess Core - Syntax Tree & Core Evaluation
+
+This is separate from the `jess` package, because it contains the AST, therefore parsers can import this package to export an AST, and `jess` can import the parser + core. (Avoids circular dependencies.)
+
+## Data structures
+
+I've fiddled around with lots of data structures trying to find optimal node insertion / removal. With the latest code, I've eliminated most (if not all?) of mid-list insertion/deletion in array-like structures. I had a lot of code based on [Queue from data-structure-typed](https://github.com/zrwusa/data-structure-typed) (and tried some other structures), but Queue is really only faster when items need to be removed / added to the beginning, because of Array resizing. If we're doing only pushes & pops, no mid-list insertions, and only indexed lookups, then a native Array will always win. In those array-like structures for that library, pushes / pops, then an Array will be fine (and its an ArrayList internally).
+
+For HashMap-like structures, I actually think using a simple extension of Map might be ideal. It's roughly the same speed as `data-structure-typed`'s HashMap, and I can do a custom clone that utilizes a [custom while loop that is currently fastest in Chrome](https://jsperf.app/savivi/6).

package/lib/context.d.ts

@@ -0,0 +1,352 @@
+import type { AtRule, Ruleset, Rules, ImportOptions, Node, Any, Selector } from './tree/index.js';
+import { ExtendRootRegistry } from './tree/util/extend-roots.js';
+import { type Operator } from './tree/util/calculate.js';
+import type { PluginInterface } from './plugin.js';
+import { EqualityMode, MathMode, UnitMode } from './types/modes.js';
+import { type ErrorDiagnostic, type WarningDiagnostic } from './jess-error.js';
+import type { Call } from './tree/call.js';
+import { CallMap } from './tree/util/recursion-helper.js';
+export interface ContextOptions {
+    /** Hash classes for module output */
+    module?: boolean;
+    /**
+     * From docs:
+     * "Changes compilation mode so dynamic content
+     * is output as CSS variables, and changes
+     * the runtime module to generate CSS patches."
+     *
+     * @todo - Change this behavior to "live expressions"
+     * i.e. change compilation to always be static, but
+     * generate a separate module for calculated CSS variables.
+     */
+    dynamic?: boolean;
+    collapseNesting?: boolean;
+    enableJavaScript?: boolean;
+    mathMode?: MathMode;
+    unitMode?: UnitMode;
+    equalityMode?: EqualityMode;
+    /** Directories to search to resolve files */
+    searchPaths?: string[];
+    /**
+     * Whether to leak variables and mixins into the caller scope,
+     * such that they can be referenced / called by subsequent rules.
+     *
+     * @deprecated - a Less feature
+     */
+    leakyRules?: boolean;
+    /**
+     * Whether to bubble root-only at-rules (like @font-face, @keyframes)
+     * to the root level when they're nested inside rulesets.
+     *
+     * @deprecated - a legacy Less feature; modern CSS allows nesting
+     */
+    bubbleRootAtRules?: boolean;
+    /**
+     * Suppress warnings (similar to Less's suppressWarnings option).
+     * When true, warnings are collected but not emitted.
+     */
+    suppressWarnings?: boolean;
+    /**
+     * Break on first error (stop processing after first error).
+     * When false, errors are collected and processing continues.
+     */
+    breakOnError?: boolean;
+}
+export interface TreeContextOptions extends ContextOptions {
+    inlineJavaScript?: boolean;
+    /**
+     * For instances where a new tree needs to inherit from scope
+     * (like Less / SCSS `@import` rule)
+     *
+     * @todo - remove?
+     */
+    parentScope?: Rules;
+    scope?: Rules;
+    isModule?: boolean;
+    file?: {
+        /** Filename, e.g. "main.jess" */
+        name: string;
+        /** Absolute directory containing the file (no filename) */
+        path: string;
+        /** Absolute file path (directory + filename) */
+        fullPath: string;
+        /** Full file contents (recommended for code-frames) */
+        source?: string;
+        /** Lazy cache of line-start offsets (built on demand) */
+        lines?: Uint32Array;
+    };
+    [k: string]: any;
+}
+/**
+ * @todo - Redo:
+ *   1. Create a hash of the file path; that way hashes
+ *      are unique per file, but also repeatable / predictable.
+ *   2. Append file (module) hash after class name
+ */
+export declare const generateId: (length?: number) => string;
+/**
+ * Tree context is attached to each node
+ * during the parsing phase / AST creation.
+ *
+ * Each file (and hence, tree) will get a new tree
+ * context. For the most part, it is passed around
+ * as an object reference.
+ *
+ * Additionally, it sets options that may be
+ * unique to the tree, such as the math mode.
+ */
+export declare class TreeContext implements TreeContextOptions {
+    opts: Record<string, any>;
+    leakyRules: boolean | undefined;
+    bubbleRootAtRules: boolean | undefined;
+    mathMode: MathMode | undefined;
+    unitMode: UnitMode | undefined;
+    equalityMode: EqualityMode | undefined;
+    /** @todo - Change how extend works based on this value */
+    isModule: boolean | undefined;
+    file?: TreeContextOptions['file'];
+    /**
+     * The plugin that created this tree. It will have first dibs
+     * to resolve any imports.
+     */
+    plugin?: PluginInterface;
+    constructor(opts?: TreeContextOptions);
+}
+/**
+ * .a.b.c
+ * simple = 0b1
+ * compound = 0b10
+ * complex = 0b100
+ * a = 0b1000
+ * b = 0b10000
+ * c = 0b100000
+ *
+ * .a.b.c.c = 0b111010
+ */
+/**
+ * This is the context object used for evaluation.
+ *
+ * @note
+ * Most of context represents "state" while evaluating.
+ * There should only ever be one Context singleton per parse & evaluation.
+ */
+export declare class Context {
+    readonly plugins: PluginInterface[];
+    readonly opts: ContextOptions;
+    treeContext: TreeContext;
+    /**
+     * Collected errors during safeParse/safeRender.
+     * Only populated when using safe methods.
+     */
+    errors: ErrorDiagnostic[];
+    /**
+     * Collected warnings during safeParse/safeRender.
+     * Only populated when using safe methods.
+     */
+    warnings: WarningDiagnostic[];
+    /**
+     * A feature ported from Less - we suppress any `@charset`
+     * after the first one.
+     */
+    currentCharset?: Any;
+    /** Track whether charset has been emitted during toString to avoid duplicates */
+    charsetEmitted?: boolean;
+    /** @import rules must be at the top of CSS output */
+    topImports?: Node[];
+    /**
+     * This is set when entering rulesets so that child nodes
+     * can use this to lookup values. When evaluating inside a mixin/function,
+     * this also enables call-time variable resolution ($~variable).
+     */
+    rulesContext: Rules;
+    /** Entire context root (ultimate root) */
+    root: Rules;
+    /** Set so that we can do ruleset selector lookup for extend */
+    treeRoot: Rules;
+    allRoots: Rules[];
+    /** The call that is currently being evaluated */
+    caller?: Call;
+    /** Extend roots registry for managing extend scoping */
+    extendRoots: ExtendRootRegistry;
+    /**
+     * Depth-first document order of each Ruleset (assigned once per root before eval).
+     * Used so processExtends can apply extends in true source order.
+     */
+    documentOrderByRuleset?: WeakMap<Ruleset, number>;
+    /**
+     * Registered extends with their extend root context
+     * Format: [target, selectorWithExtend, partial, extendRoot, extendNode, documentOrder?]
+     */
+    extends: Array<[target: Selector, selectorWithExtend: Selector, partial: boolean, extendRoot: Rules, extendNode: Node, documentOrder?: number, fromReferenceScope?: boolean]>;
+    /**
+     * When doing any kind of lookup, the current node and resolved
+     * nodes in the search chain are added to prevent recursion errors.
+     *
+     * We use a set here because we look it up for filtering.
+     * Also used to track mixins currently being evaluated to prevent infinite recursion.
+     */
+    private _searchScope;
+    get searchScope(): Set<Node<unknown, import("./tree/node-base.js").NodeOptions>>;
+    /**
+     * The file (eval) context should have the same ID at compile-time
+     * as run-time, so this ID will be set in `toModule()` output
+     *
+     * @todo - Make the id a hash of the (project-relative) path + contents
+     */
+    id: string;
+    ruleCounter: number;
+    /** Rules depth, used to figure out source order */
+    depth: number;
+    private _classMap;
+    get classMap(): Map<any, any>;
+    /** Frames for nested rulesets, used for selector evaluation */
+    rulesetFrames: Ruleset[];
+    /** Unified frames array for flat rendering when collapseNesting is true */
+    frames: (Ruleset | AtRule)[];
+    /**
+     * We push a boolean to this array when entering a calc() call
+     * and pop it when leaving. This helps us determine if operations
+     * should be performed or not.
+     *
+     * @todo - can't this just be a number?
+     */
+    calcFrames: number;
+    private _callMap;
+    get callMap(): CallMap;
+    private _callStack;
+    get callStack(): Call[];
+    /**
+     * Stack to track reference call chain for clearing matched keys at outermost level
+     */
+    private _referenceStack;
+    get referenceStack(): number;
+    /**
+     * Import-evaluation scope stack.
+     *
+     * This intentionally models lexical import scope instead of global counters:
+     * - each import branch pushes its semantics on entry
+     * - each branch pops in `finally`
+     * - readers ask semantic questions (`inReferenceImportScope`) instead of
+     *   inspecting mutable depth values.
+     *
+     * Why this exists:
+     * some behaviors depend on "how we got here" (call-path scope), not only
+     * on the current node's own options. Example: suppressing top-level @import
+     * hoists while traversing a reference-only branch.
+     */
+    private _importScopeStack;
+    get importScope(): {
+        reference: boolean;
+        multiple: boolean;
+    }[];
+    get inReferenceImportScope(): boolean;
+    get inMultipleImportScope(): boolean;
+    pushImportScope(scope: {
+        reference?: boolean;
+        multiple?: boolean;
+    }): void;
+    popImportScope(): void;
+    pushReference(): void;
+    /**
+     * Stack to track when a value comes from an important declaration
+     * Used to propagate !important flag to containing declarations
+     */
+    private _importantSourceStack;
+    get hasImportantSource(): boolean;
+    pushImportantSource(): void;
+    popImportantSource(): void;
+    popReference(): void;
+    rulesEvalStack: Rules[];
+    /**
+     * We push a boolean to this array when entering parens call
+     * and pop it when leaving. This helps us determine if operations
+     * should be performed or not.
+     *
+     * Sometimes we "reset" the "in parentheses" state by pushing false,
+     * such as within a function call.
+     */
+    parenFrames: boolean[];
+    /**
+     * Keys of @let variables --
+     * We need this b/c we need to generate code
+     * for over-riding in the exported function.
+     *
+     * @todo - remove?
+     */
+    private _exports;
+    get exports(): Set<string>;
+    /**
+     * currently generating a runtime module or not
+     * @todo - remove in favor of ToModuleVisitor?
+     */
+    /**
+     * In a custom declaration's value. All nodes should
+     * be preserved as-is and not evaluated, except for
+     * $() expressions.
+    */
+    inCustom: boolean | undefined;
+    /** A flag set when evaluating conditions */
+    isDefault: boolean | undefined;
+    /** A flag to clone nodes before mutating */
+    preserveOriginalNodes: boolean | undefined;
+    _leakyRules: boolean | undefined;
+    get leakyRules(): boolean;
+    _bubbleRootAtRules: boolean | undefined;
+    get bubbleRootAtRules(): boolean;
+    constructor(opts?: ContextOptions, plugins?: PluginInterface[]);
+    /** Full resolved path -> tree */
+    sourceTrees: Map<string, Rules>;
+    evaldTrees: Map<string, Rules>;
+    /**
+     * @param importPath - The bare import path e.g. `@import "foo";` in a .less file.
+     */
+    private _getPath;
+    /**
+     * Find the appropriate plugin for parsing based on type or extension
+     */
+    private findParserPlugin;
+    getTree(importPath: string, importOptions?: ImportOptions): Promise<{
+        node: any;
+        triedPaths: string[];
+        resolvedPath: string;
+    }>;
+    /**
+     * Public path resolution for import nodes that need source-path lookups
+     * without triggering parse/eval.
+     */
+    resolveImportPath(importPath: string): Promise<{
+        triedPaths: string[];
+        resolvedPath: string;
+        friendlyPath: string;
+    }>;
+    /**
+     * Parse a string content directly using the appropriate plugin
+     */
+    parseString(content: string, options?: {
+        filePath?: string;
+        type?: string;
+        extension?: string;
+    }): Promise<{
+        node: Rules;
+        resolvedPath: string;
+    }>;
+    /**
+     *
+     * @param importPath
+     * @param importOptions
+     */
+    getModule(importPath: string, importOptions?: ImportOptions): Promise<{
+        module: Record<string, any>;
+        triedPaths: string[];
+        resolvedPath: string;
+    }>;
+    /**
+     * Hash a CSS class name or not depending on the `module` setting
+     *
+     * @todo - do module files have different contexts, therefore different
+     * hash maps?
+     */
+    hashClass(name: string): string;
+    shouldOperate(op: Operator, left: Node, right: Node): boolean;
+}
+//# sourceMappingURL=context.d.ts.map

package/lib/context.d.ts.map

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