@jesscss/core 2.0.0-alpha.5 → 2.0.0-alpha.6

package/src/tree/selector-pseudo.ts

@@ -0,0 +1,173 @@
+import {
+  defineType,
+  Node,
+  type OptionalLocation,
+  type NodeOptions,
+  type TreeContext
+} from './node.js';
+import { SimpleSelector } from './selector-simple.js';
+import { type Context } from '../context.js';
+import { isNode } from './util/is-node.js';
+import { N } from './node-type.js';
+import { Selector } from './selector.js';
+import { type PrintOptions, getPrintOptions } from './util/print.js';
+import { type MaybePromise, pipe } from '@jesscss/awaitable-pipe';
+
+export type PseudoSelectorValue = {
+  /**
+   * The name of the pseudo-selector
+   * @note - this will contain the `:` prefix,
+   * to support `::before` and `::after`
+   */
+  name: string;
+  arg?: Node;
+};
+
+export type PseudoSelectorChildData = { name: string; arg: Node | undefined };
+
+/**
+ * A pseudo selector
+ * @see https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Selectors/Pseudo-classes_and_pseudo-elements
+ *   e.g. :hover, :focus, :active
+*/
+export interface PseudoSelector {
+  type: 'PseudoSelector';
+  shortType: 'pseudo';
+}
+export class PseudoSelector extends SimpleSelector<PseudoSelectorValue, NodeOptions, PseudoSelectorChildData> {
+  static override childKeys = ['name', 'arg'] as const;
+
+  name!: string;
+  arg: Node | undefined;
+
+  constructor(value: PseudoSelectorValue, options?: NodeOptions, location?: OptionalLocation, treeContext?: TreeContext) {
+    super(value, options, location, treeContext);
+    this.name = value.name;
+    this.arg = value.arg;
+    if (this.arg instanceof Node) {
+      this.adopt(this.arg);
+    }
+  }
+
+  override computeKeySets(): void {
+    if (this._keySet && this._visibleKeySet && this._requiredKeySet) {
+      return;
+    }
+    let name = this.name;
+    let arg: unknown = this.arg;
+    let library = this.keySetLibrary;
+    if (!library) {
+      throw new Error('Selector keySet library not found');
+    }
+    if (isNode(arg, N.Selector)) {
+      if (name === ':is') {
+        this._keySet = arg.keySet;
+        this._visibleKeySet = arg.visibleKeySet;
+        if (isNode(arg, N.SelectorList)) {
+          this._requiredKeySet = library.getBitset();
+        } else {
+          this._requiredKeySet = arg.requiredKeySet;
+        }
+      } else {
+        let pos = library.add(name);
+        let keySet = this._keySet = arg.keySet.clone();
+        let visibleKeySet = this._visibleKeySet = arg.visibleKeySet.clone();
+        keySet.set(pos, 1);
+        visibleKeySet.set(pos, 1);
+        this._requiredKeySet = arg.requiredKeySet.clone();
+        this._requiredKeySet.set(pos, 1);
+      }
+    } else {
+      this._keySet = library.getBitset([this.valueOf()]);
+      this._visibleKeySet = this._keySet;
+      this._requiredKeySet = this._keySet;
+    }
+  }
+
+  override toTrimmedString(options?: PrintOptions) {
+    options = getPrintOptions(options);
+    const w = options.writer!;
+    const context = options.context;
+    const name = this.get('name', context);
+    const arg = this.get('arg', context);
+    const mark = w.mark();
+    if (this.generated && name === ':is' && arg && isNode(arg, N.SelectorList)) {
+      let out = w.capture(() => arg.toString(options));
+      out = out.replace(/\n\s*/g, ' ').trimEnd();
+      if (!out.includes(',')) {
+        w.add(out, arg);
+        return w.getSince(mark);
+      }
+      w.add(name, this);
+      w.add('(');
+      w.add(out, arg);
+      w.add(')');
+      return w.getSince(mark);
+    }
+    w.add(name, this);
+    if (arg) {
+      w.add('(');
+      if (isNode(arg, N.SelectorList)) {
+        let out = w.capture(() => arg.toString(options));
+        out = out.replace(/\n\s*/g, ' ').trimEnd();
+        w.add(out, arg);
+      } else {
+        let out = w.capture(() => arg.toString(options));
+        w.add(out.trimEnd(), arg);
+      }
+      w.add(')');
+    }
+    return w.getSince(mark);
+  }
+
+  override valueOf(): string {
+    let valueOf = this._valueOf;
+    if (!valueOf) {
+      let name = this.name;
+      let arg = this.arg;
+      valueOf = `${name}${arg ? `(${arg.valueOf()})` : ''}`;
+      this._valueOf = valueOf;
+    }
+    return valueOf;
+  }
+
+  override evalNode(context: Context): MaybePromise<PseudoSelector> {
+    const currentArg = this.get('arg', context);
+    const node = super.evalNode(context) as PseudoSelector;
+    if (!currentArg) {
+      return node;
+    }
+    return pipe(
+      () => {
+        context.parenFrames.push(false);
+        return currentArg.eval(context);
+      },
+      (evaluatedArg) => {
+        context.parenFrames.pop();
+        if (node === this) {
+          const out = this.clone() as PseudoSelector;
+          out.inherit(this);
+          out.adopt(evaluatedArg, context);
+          out.arg = evaluatedArg;
+          return out;
+        }
+        node.adopt(evaluatedArg, context);
+        node.arg = evaluatedArg;
+        return node;
+      }
+    );
+  }
+}
+
+export const pseudo = defineType<PseudoSelectorValue, typeof PseudoSelector>(PseudoSelector, 'PseudoSelector', 'pseudo');
+
+/**
+ * Convenience function to create a :is() pseudo-selector
+ * @param arg The selector that goes inside :is()
+ * @returns A PseudoSelector with name ":is" and the provided selector as argument
+ */
+export function is(arg: Selector): PseudoSelector {
+  const p = pseudo({ name: ':is', arg });
+  p.generated = true;
+  return p;
+}

package/src/tree/selector-simple.ts

@@ -0,0 +1,10 @@
+import { type NodeOptions, defineType } from './node.js';
+import { Selector } from './selector.js';
+
+export abstract class SimpleSelector<
+  T = any,
+  O extends NodeOptions = NodeOptions,
+  CD extends Record<string, unknown> = Record<string, unknown>
+> extends Selector<T, O, CD> {}
+
+defineType(SimpleSelector, 'SimpleSelector');

package/src/tree/selector.ts

@@ -0,0 +1,152 @@
+import type { MaybePromise } from 'awaitable-pipe';
+import { F_VISIBLE, Node, type NodeOptions, type NodeValue, defineType } from './node.js';
+import type { IfAny } from 'type-fest';
+import type { Context } from '../context.js';
+import type { Nil } from './nil.js';
+import { type BitSetLibrary, BitSet } from './util/bitset.js';
+
+const { isArray } = Array;
+/**
+ * This represents anything that is valid in a selector
+ *
+ * @todo - Add Sass private / placeholder selectors?
+ *   e.g. `\\foo` instead of `%foo`
+ *       private = `\\_foo`
+ */
+
+export interface Selector<T = any, O extends NodeOptions = NodeOptions, CD extends Record<string, unknown> = Record<string, unknown>> extends Node<IfAny<T, NodeValue, T>, O, CD> {
+  valueOf(): string;
+  getKeySet(context?: Context): BitSet<string>;
+  eval(context: Context): MaybePromise<Selector<T>> | MaybePromise<Nil>;
+}
+
+export abstract class Selector<T = any, O extends NodeOptions = NodeOptions, CD extends Record<string, unknown> = Record<string, unknown>> extends Node<IfAny<T, NodeValue, T>, O, CD> {
+  isSelector = true;
+
+  protected _valueOf: string | undefined;
+
+  keySetLibrary: BitSetLibrary<string> | undefined;
+
+  private _seedKeySetLibrary(library: BitSetLibrary<string>): void {
+    this.keySetLibrary = library;
+    for (const child of this.children(true)) {
+      if ((child as Selector).isSelector) {
+        (child as Selector).keySetLibrary = library;
+      }
+    }
+  }
+
+  protected override evalNode(context: Context): MaybePromise<Node> {
+    this._seedKeySetLibrary(context.selectorBits);
+    if (this.sourceNode !== this && (this.sourceNode as Selector).isSelector) {
+      (this.sourceNode as Selector)._seedKeySetLibrary(context.selectorBits);
+    }
+    return super.evalNode(context);
+  }
+
+  /**
+   * A set of all simplified (valueOf) selectors,
+   * for easy lookup to see if the selector is extendable
+   * by the key sets in the extend scope.
+   */
+  protected _keySet: BitSet<string> | undefined;
+  /** Used for mixin registry indexing - only includes visible selectors */
+  protected _visibleKeySet: BitSet<string> | undefined;
+  /**
+   * Like keySet but excludes keys inside `:is()` SelectorList args.
+   * For `:is(.a, .b) .c`, requiredKeySet = `{.c}` while keySet = `{.a, .b, .c}`.
+   * Safe for subset rejection: if requiredKeySet keys aren't in target, no match possible.
+   */
+  protected _requiredKeySet: BitSet<string> | undefined;
+
+  get keySet() {
+    if (!this._keySet) {
+      this.computeKeySets();
+    }
+    return this._keySet!;
+  }
+
+  getKeySet(context?: Context): BitSet<string> {
+    if (!context) {
+      return this.keySet;
+    }
+    let library = this.keySetLibrary;
+    if (!library) {
+      throw new Error('Selector keySet library not found');
+    }
+
+    let children = (this as any).value;
+    if (isArray(children)) {
+      let keySet: BitSet<string> | undefined;
+      for (const child of children as Selector[]) {
+        let childKeySet = child.getKeySet(context);
+        keySet = keySet ? keySet.or(childKeySet) : childKeySet.clone();
+      }
+      return keySet ?? library.getBitset();
+    }
+
+    let value = String((this as unknown as { valueOf(context?: Context): string }).valueOf(context));
+    return library.getBitset([value]);
+  }
+
+  get visibleKeySet() {
+    if (!this._visibleKeySet) {
+      this.computeKeySets();
+    }
+    return this._visibleKeySet!;
+  }
+
+  get requiredKeySet() {
+    if (!this._requiredKeySet) {
+      this.computeKeySets();
+    }
+    return this._requiredKeySet!;
+  }
+
+  invalidateCache(): void {
+    this._valueOf = undefined;
+    this._keySet = undefined;
+    this._visibleKeySet = undefined;
+    this._requiredKeySet = undefined;
+  }
+
+  /**
+   * Computes keySet, visibleKeySet, and requiredKeySet in one pass.
+   * Subclasses should override this to implement their specific logic.
+   */
+  protected computeKeySets(): void {
+    if (this._keySet && this._visibleKeySet && this._requiredKeySet) {
+      return;
+    }
+    let library = this.keySetLibrary;
+    if (!library) {
+      throw new Error('Selector keySet library not found');
+    }
+
+    let children = (this as any).value;
+    if (isArray(children)) {
+      for (const child of children as Selector[]) {
+        let childKeySet = child.keySet;
+        this._keySet = this._keySet ? this._keySet.or(childKeySet) : childKeySet.clone();
+        this._visibleKeySet = this._visibleKeySet
+          ? this._visibleKeySet.or(child.visibleKeySet)
+          : child.visibleKeySet.clone();
+        this._requiredKeySet = this._requiredKeySet
+          ? this._requiredKeySet.or(child.requiredKeySet)
+          : child.requiredKeySet.clone();
+      }
+      return;
+    }
+    let value = String(this.valueOf());
+    this._keySet = library.getBitset([value]);
+    this._requiredKeySet = this._keySet;
+
+    if (this.hasFlag(F_VISIBLE)) {
+      this._visibleKeySet = this._keySet;
+    } else {
+      this._visibleKeySet = library.getBitset();
+    }
+  }
+}
+
+defineType(Selector, 'Selector');