nudge-ui 0.2.0 → 0.2.1

package/dist/inspector/tokens/resolution/selectorSemantics.js

@@ -17,7 +17,7 @@ function extractParenContent(source, openIndex) {
     }
     return { content: source.slice(start, index - 1).trim(), end: index };
 }
-function splitSelectorAtTopLevel(selector, separator) {
+export function splitSelectorAtTopLevel(selector, separator) {
     const parts = [];
     let depth = 0;
     let start = 0;
@@ -44,11 +44,11 @@ function splitSelectorAtTopLevel(selector, separator) {
 const SPECIFICITY_MEMO_LIMIT = 10_000;
 const specificityMemo = new Map();
 let specificityComputations = 0;
-/** Number of unique selector strings actually computed (for tests). */
+/** Test-only specificity cache size. */
 export function specificityComputationCount() {
     return specificityComputations;
 }
-/** Clears the specificity memo (for tests). */
+/** Test-only specificity cache reset. */
 export function resetSpecificityMemo() {
     specificityMemo.clear();
     specificityComputations = 0;
@@ -69,7 +69,7 @@ export function computeSpecificity(selectorText) {
     specificityMemo.set(selectorText, result);
     return result;
 }
-/** The unmemoized implementation, exposed for equivalence tests. */
+/** Unmemoized implementation used by equivalence tests. */
 export function computeSpecificityCore(selectorText) {
     const selector = selectorText.trim();
     const commaParts = splitSelectorAtTopLevel(selector, ",");
@@ -104,3 +104,377 @@ export function computeSpecificityCore(selectorText) {
     }
     return idCount * 1000000 + classCount * 10000 + elementCount * 100;
 }
+const SELECTOR_PSEUDO_CLASS_CACHE_MAX = 16_384;
+const selectorPseudoClassMemo = new Map();
+export function selectorPseudoClasses(selector) {
+    const cached = selectorPseudoClassMemo.get(selector);
+    if (cached)
+        return cached;
+    const matches = [];
+    let attributeDepth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < selector.length; index++) {
+        const character = selector[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (attributeDepth > 0) {
+            if (character === '"' || character === "'")
+                quote = character;
+            else if (character === "[")
+                attributeDepth++;
+            else if (character === "]")
+                attributeDepth--;
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === "[") {
+            attributeDepth = 1;
+            continue;
+        }
+        if (character !== ":" || selector[index - 1] === ":" || selector[index + 1] === ":")
+            continue;
+        const name = /^[A-Za-z-]+/.exec(selector.slice(index + 1))?.[0];
+        if (!name)
+            continue;
+        matches.push({ name: name.toLowerCase(), start: index, end: index + name.length + 1 });
+        index += name.length;
+    }
+    if (selectorPseudoClassMemo.size >= SELECTOR_PSEUDO_CLASS_CACHE_MAX)
+        selectorPseudoClassMemo.clear();
+    selectorPseudoClassMemo.set(selector, matches);
+    return matches;
+}
+export function hasSelectorPseudoClass(selector, names) {
+    return selectorPseudoClasses(selector).some(({ name }) => names.has(name));
+}
+const STATIC_SELECTOR_FUNCTIONS = new Set(["is", "where", "not"]);
+const STATIC_PSEUDO_CLASSES = new Set(["host", "root"]);
+const SELECTOR_SENSITIVITY_CACHE_MAX = 16_384;
+const selectorSensitivityMemo = new Map();
+function selectorFunctionEnd(selector, openingIndex) {
+    let parentheses = 0;
+    let brackets = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = openingIndex; index < selector.length; index++) {
+        const character = selector[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === "[") {
+            brackets++;
+            continue;
+        }
+        if (character === "]") {
+            brackets = Math.max(0, brackets - 1);
+            continue;
+        }
+        if (brackets > 0)
+            continue;
+        if (character === "(") {
+            parentheses++;
+        }
+        else if (character === ")") {
+            parentheses--;
+            if (parentheses === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+export function isElementSensitiveSelector(selector) {
+    const cached = selectorSensitivityMemo.get(selector);
+    if (cached !== undefined)
+        return cached;
+    const result = computeElementSensitiveSelector(selector);
+    if (selectorSensitivityMemo.size >= SELECTOR_SENSITIVITY_CACHE_MAX)
+        selectorSensitivityMemo.clear();
+    selectorSensitivityMemo.set(selector, result);
+    return result;
+}
+function computeElementSensitiveSelector(selector) {
+    let attributeDepth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < selector.length; index++) {
+        const character = selector[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (attributeDepth > 0) {
+            if (character === '"' || character === "'")
+                quote = character;
+            else if (character === "[")
+                attributeDepth++;
+            else if (character === "]")
+                attributeDepth--;
+            continue;
+        }
+        // Tailwind escapes utility variants such as `.sm\\:text-red-500`. The
+        // escaped colon is part of the class name, not a pseudo-class boundary.
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === "[") {
+            attributeDepth = 1;
+            continue;
+        }
+        if (character === "+" || character === "~")
+            return true;
+        if (character !== ":")
+            continue;
+        const pseudoElement = selector[index + 1] === ":";
+        const pseudo = /^[A-Za-z-]+/.exec(selector.slice(index + (pseudoElement ? 2 : 1)))?.[0];
+        if (pseudoElement) {
+            // Pseudo-elements do not change whether the originating element matches
+            // a selector. Continue scanning after the name so a real pseudo-class
+            // elsewhere in the selector remains element-sensitive.
+            if (!pseudo)
+                return true;
+            index += pseudo.length + 1;
+            let next = index + 1;
+            while (next < selector.length && /\s/.test(selector[next]))
+                next++;
+            if (selector[next] === "(")
+                return true;
+            continue;
+        }
+        if (!pseudo)
+            continue;
+        const pseudoName = pseudo.toLowerCase();
+        index += pseudo.length;
+        let next = index + 1;
+        while (next < selector.length && /\s/.test(selector[next]))
+            next++;
+        if (STATIC_SELECTOR_FUNCTIONS.has(pseudoName) && selector[next] === "(") {
+            const end = selectorFunctionEnd(selector, next);
+            if (end < 0 || isElementSensitiveSelector(selector.slice(next + 1, end)))
+                return true;
+            index = end;
+            continue;
+        }
+        // :root and :host are represented by the complete ancestor/document
+        // context. Other pseudo-classes can vary per concrete element without an
+        // attribute or sibling mutation (for example :checked, :visited, and
+        // :target), so keep them in the element-sensitive bucket.
+        if (STATIC_PSEUDO_CLASSES.has(pseudoName))
+            continue;
+        return true;
+    }
+    return false;
+}
+function selectorSubject(selector) {
+    let start = 0;
+    let parentheses = 0;
+    let brackets = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < selector.length; index++) {
+        const character = selector[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === "[") {
+            brackets++;
+            continue;
+        }
+        if (character === "]") {
+            brackets = Math.max(0, brackets - 1);
+            continue;
+        }
+        if (brackets > 0)
+            continue;
+        if (character === "(") {
+            parentheses++;
+            continue;
+        }
+        if (character === ")") {
+            parentheses = Math.max(0, parentheses - 1);
+            continue;
+        }
+        if (parentheses > 0)
+            continue;
+        if (character === ">" || character === "+" || character === "~" || /\s/.test(character)) {
+            start = index + 1;
+        }
+    }
+    return selector.slice(start).trim();
+}
+function cssIdentifierEnd(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\\") {
+            index++;
+            if (index >= source.length)
+                break;
+            if (/[0-9a-fA-F]/.test(source[index])) {
+                let digits = 0;
+                while (index < source.length && digits < 6 && /[0-9a-fA-F]/.test(source[index])) {
+                    index++;
+                    digits++;
+                }
+                if (/\s/.test(source[index] ?? ""))
+                    index++;
+            }
+            else {
+                index++;
+            }
+            continue;
+        }
+        if (!/[A-Za-z0-9_-]/.test(character) && character.charCodeAt(0) < 0x80)
+            break;
+        index++;
+    }
+    return index;
+}
+function unescapeCssIdentifier(value) {
+    return value
+        .replace(/\\([0-9a-fA-F]{1,6})(?:\s)?/g, (_match, hex) => {
+        const codePoint = Number.parseInt(hex, 16);
+        return codePoint === 0
+            || codePoint > 0x10FFFF
+            || (codePoint >= 0xD800 && codePoint <= 0xDFFF)
+            ? "\uFFFD"
+            : String.fromCodePoint(codePoint);
+    })
+        .replace(/\\(.)/g, "$1");
+}
+const SELECTOR_CLASS_REQUIREMENTS_CACHE_MAX = 16_384;
+const selectorClassRequirementsMemo = new Map();
+function selectorClassRequirements(selector) {
+    const cached = selectorClassRequirementsMemo.get(selector);
+    if (cached)
+        return cached;
+    const subject = selectorSubject(selector);
+    const requirements = [];
+    let parentheses = 0;
+    let brackets = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < subject.length; index++) {
+        const character = subject[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === "[") {
+            brackets++;
+            continue;
+        }
+        if (character === "]") {
+            brackets = Math.max(0, brackets - 1);
+            continue;
+        }
+        if (brackets > 0)
+            continue;
+        if (character === "(") {
+            parentheses++;
+            continue;
+        }
+        if (character === ")") {
+            parentheses = Math.max(0, parentheses - 1);
+            continue;
+        }
+        if (parentheses > 0 || character !== ".")
+            continue;
+        const end = cssIdentifierEnd(subject, index + 1);
+        const className = unescapeCssIdentifier(subject.slice(index + 1, end));
+        if (className)
+            requirements.push(className);
+        index = end - 1;
+    }
+    if (selectorClassRequirementsMemo.size >= SELECTOR_CLASS_REQUIREMENTS_CACHE_MAX) {
+        selectorClassRequirementsMemo.clear();
+    }
+    selectorClassRequirementsMemo.set(selector, requirements);
+    return requirements;
+}
+/**
+ * Rejects selectors whose rightmost compound requires a class the element
+ * does not have. This is a conservative prefilter: it only returns false for
+ * an impossible positive class requirement and leaves all other selectors to
+ * the browser's selector engine.
+ */
+export function canMatchSelectorSubject(el, selector) {
+    return selectorClassRequirements(selector).every((className) => el.classList.contains(className));
+}

package/dist/inspector/tokens/resolution.d.ts

@@ -1,7 +1,8 @@
-import type { TokenDefinition, TokenEntry } from "../../css/model/index.js";
 import type { InteractionState } from "../shell/styleState.js";
-export { invalidateStyleResolutionCache } from "./resolution/cssomCollector.js";
 import type { MatchedRule, ResolvedProperty, TokenTable } from "../../css/model/index.js";
+export { getAvailableInteractionStates, resetSourceSiteMatchCache, sourceSiteMatchCacheSize } from "./resolution/ruleMatching.js";
+export { buildTokenTable, getTokenTable, getAvailableTokenEntriesForElement, getAvailableTokenCatalog } from "./tokenAvailability.js";
+export { invalidateStyleResolutionCache } from "./resolution/cssomCollector.js";
 /**
  * Builds (or reuses) the document's CSSOM rule snapshot ahead of a resolution
  * sweep. Idempotent: the walk runs once per stylesheet revision and is a cache
@@ -9,29 +10,6 @@ import type { MatchedRule, ResolvedProperty, TokenTable } from "../../css/model/
  * subsequent resolution sweep's blocking time small.
  */
 export declare function prewarmCssomRuleSnapshot(doc: Document): void;
-export declare function buildTokenTable(entries: readonly TokenEntry[]): TokenTable;
-export declare function getTokenTable(): TokenTable;
-/**
- * The build-time catalog is intentionally an inventory of every project token.
- * Element edits must instead use only custom properties resolved in that
- * element's cascade; a token defined by a lazy stylesheet is not usable until
- * that stylesheet is attached to the document. Entries are cached per element
- * until the element or stylesheet revision changes; the derived table reuses
- * `buildTokenTable`'s input-identity memo.
- */
-export declare function getAvailableTokenEntriesForElement(el: HTMLElement, definitions?: readonly TokenDefinition[]): TokenEntry[];
-/**
- * Produces the page catalog used by the global Tokens settings section. It retains the
- * build-time inventory separately, while removing declarations from CSS files
- * that have not loaded when the document exposes mappable source identities
- * (such as Vite's lazy route stylesheets). Opaque compiled URLs do not narrow
- * the adapter-supplied catalog.
- */
-export declare function getAvailableTokenCatalog(root?: HTMLElement, definitions?: readonly TokenDefinition[]): TokenDefinition[];
-/** Test hook: clears the per-source-site matched-rule cache. */
-export declare function resetSourceSiteMatchCache(): void;
-/** Test hook: number of distinct cached source-site match sets. */
-export declare function sourceSiteMatchCacheSize(): number;
 /**
  * Package-private cascade fixture seam. This exercises selector, layer,
  * importance, and interaction-state coordination while still crossing the
@@ -47,7 +25,6 @@ export declare function getResolvedProperties(el: HTMLElement, tokenTable: Token
  * computed value in the field layer.
  */
 export declare function getResolvedPropertiesForState(el: HTMLElement, tokenTable: TokenTable, state: InteractionState): ResolvedProperty[];
-export declare function getAvailableInteractionStates(el: HTMLElement): InteractionState[];
 /**
  * Resolves the cascade with transient interaction selectors removed. Used when
  * an editor must stay linked to the stable token beneath a live :hover/:focus