@svelterm/core 0.1.0

package/dist/src/css/incremental.js

@@ -0,0 +1,46 @@
+import { resolveNode } from './compute.js';
+import { collectVariables } from './variables.js';
+const LAYOUT_PROPERTIES = [
+    'display', 'flexDirection', 'justifyContent', 'alignItems', 'alignSelf',
+    'gap', 'flexGrow', 'flexShrink', 'flexWrap',
+    'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft',
+    'marginTop', 'marginRight', 'marginBottom', 'marginLeft',
+    'width', 'height', 'minWidth', 'minHeight', 'maxWidth', 'maxHeight',
+    'borderStyle', 'borderTop', 'borderRight', 'borderBottom', 'borderLeft',
+    'position', 'top', 'right', 'bottom', 'left',
+    'overflow', 'whiteSpace',
+];
+/**
+ * Incremental style resolution — re-resolves dirty nodes and their
+ * descendants using the same resolveNode function as full resolution.
+ * Variables are collected once from the full tree for consistency.
+ */
+export function resolveStylesIncremental(root, stylesheet, existingStyles, dirtyNodes, onResolve, onLayoutAffected) {
+    if (dirtyNodes.size === 0)
+        return existingStyles;
+    // Collect variables from the full tree — same as full resolution
+    const variables = collectVariables(root, stylesheet);
+    // Start with existing styles
+    const result = new Map(existingStyles);
+    for (const node of dirtyNodes) {
+        if (node.nodeType !== 'element')
+            continue;
+        const oldStyle = existingStyles.get(node.id);
+        // Re-resolve this node and all its descendants using the
+        // same resolveNode function as full resolution
+        resolveNode(node, stylesheet, result, variables);
+        onResolve?.(node.id);
+        const newStyle = result.get(node.id);
+        if (oldStyle && newStyle && onLayoutAffected && isLayoutAffecting(oldStyle, newStyle)) {
+            onLayoutAffected(node);
+        }
+    }
+    return result;
+}
+function isLayoutAffecting(oldStyle, newStyle) {
+    for (const prop of LAYOUT_PROPERTIES) {
+        if (oldStyle[prop] !== newStyle[prop])
+            return true;
+    }
+    return false;
+}

package/dist/src/css/index.d.ts

@@ -0,0 +1,5 @@
+export { parseCSS } from './parser.js';
+export type { CSSRule, CSSDeclaration, CSSStyleSheet } from './parser.js';
+export { matchesSelector, parseSelector } from './selector.js';
+export { resolveStyles } from './compute.js';
+export type { ResolvedStyle } from './compute.js';

package/dist/src/css/index.js

@@ -0,0 +1,3 @@
+export { parseCSS } from './parser.js';
+export { matchesSelector, parseSelector } from './selector.js';
+export { resolveStyles } from './compute.js';

package/dist/src/css/media.d.ts

@@ -0,0 +1,11 @@
+export interface MediaContext {
+    colorScheme: 'dark' | 'light';
+    displayMode: 'terminal' | 'screen';
+    width: number;
+    height: number;
+}
+/**
+ * Evaluate a media query condition against the current context.
+ * Supports: single conditions, "and" compound, "not" prefix.
+ */
+export declare function evaluateMediaQuery(condition: string, context: MediaContext): boolean;

package/dist/src/css/media.js

@@ -0,0 +1,59 @@
+/**
+ * Evaluate a media query condition against the current context.
+ * Supports: single conditions, "and" compound, "not" prefix.
+ */
+export function evaluateMediaQuery(condition, context) {
+    const trimmed = condition.trim();
+    // Handle "not" prefix
+    if (trimmed.startsWith('not ')) {
+        return !evaluateMediaQuery(trimmed.substring(4), context);
+    }
+    // Handle "and" compound: split on " and " or ") and ("
+    if (trimmed.includes(' and ')) {
+        const parts = splitAnd(trimmed);
+        return parts.every(part => evaluateSingle(part.trim(), context));
+    }
+    return evaluateSingle(trimmed, context);
+}
+function splitAnd(condition) {
+    // Split on ") and (" or " and "
+    return condition.split(/\)\s*and\s*\(|\s+and\s+/).map(part => {
+        // Strip outer parens
+        let p = part.trim();
+        if (p.startsWith('('))
+            p = p.substring(1);
+        if (p.endsWith(')'))
+            p = p.substring(0, p.length - 1);
+        return p.trim();
+    });
+}
+function evaluateSingle(condition, context) {
+    // Strip outer parens
+    let c = condition.trim();
+    if (c.startsWith('('))
+        c = c.substring(1);
+    if (c.endsWith(')'))
+        c = c.substring(0, c.length - 1);
+    c = c.trim();
+    const colonIdx = c.indexOf(':');
+    if (colonIdx === -1)
+        return false;
+    const feature = c.substring(0, colonIdx).trim();
+    const value = c.substring(colonIdx + 1).trim();
+    switch (feature) {
+        case 'prefers-color-scheme':
+            return value === context.colorScheme;
+        case 'display-mode':
+            return value === context.displayMode;
+        case 'min-width':
+            return context.width >= parseInt(value);
+        case 'max-width':
+            return context.width <= parseInt(value);
+        case 'min-height':
+            return context.height >= parseInt(value);
+        case 'max-height':
+            return context.height <= parseInt(value);
+        default:
+            return false;
+    }
+}

package/dist/src/css/parser.d.ts

@@ -0,0 +1,20 @@
+export interface CSSDeclaration {
+    property: string;
+    value: string;
+}
+export interface CSSRule {
+    selectors: string[];
+    declarations: CSSDeclaration[];
+    media?: string;
+    supports?: string;
+    container?: string;
+}
+export interface KeyframeStop {
+    offset: number;
+    declarations: CSSDeclaration[];
+}
+export interface CSSStyleSheet {
+    rules: CSSRule[];
+    keyframes: Map<string, KeyframeStop[]>;
+}
+export declare function parseCSS(css: string): CSSStyleSheet;

package/dist/src/css/parser.js

@@ -0,0 +1,241 @@
+export function parseCSS(css) {
+    const rules = [];
+    const keyframes = new Map();
+    let pos = 0;
+    while (pos < css.length) {
+        pos = skipWhitespaceAndComments(css, pos);
+        if (pos >= css.length)
+            break;
+        // Check for @-rules
+        if (css.substring(pos, pos + 6) === '@media') {
+            pos = parseMediaBlock(css, pos, rules);
+            continue;
+        }
+        if (css.substring(pos, pos + 9) === '@supports') {
+            pos = parseSupportsBlock(css, pos, rules);
+            continue;
+        }
+        if (css.substring(pos, pos + 10) === '@container') {
+            pos = parseContainerBlock(css, pos, rules);
+            continue;
+        }
+        if (css.substring(pos, pos + 11) === '@keyframes ') {
+            pos = parseKeyframesBlock(css, pos, keyframes);
+            continue;
+        }
+        if (css.substring(pos, pos + 7) === '@import') {
+            // Skip @import — handled by bundler
+            pos = css.indexOf(';', pos);
+            if (pos === -1)
+                pos = css.length;
+            else
+                pos++;
+            continue;
+        }
+        pos = parseRule(css, pos, rules, undefined);
+    }
+    return { rules, keyframes };
+}
+function parseMediaBlock(css, start, rules) {
+    let pos = start + 6; // skip "@media"
+    pos = skipWhitespace(css, pos);
+    // Capture everything between @media and { as the condition string
+    const bracePos = css.indexOf('{', pos);
+    if (bracePos === -1)
+        return skipToClosingBrace(css, pos);
+    const rawCondition = css.substring(pos, bracePos).trim();
+    // Strip outer parens if single condition: "(foo: bar)" -> "foo: bar"
+    // Keep as-is for compound: "(foo: bar) and (baz: qux)"
+    const condition = rawCondition.startsWith('(') && !rawCondition.includes(') and (')
+        ? rawCondition.slice(1, -1).trim()
+        : rawCondition;
+    pos = bracePos + 1;
+    // Parse rules inside the @media block
+    while (pos < css.length) {
+        pos = skipWhitespaceAndComments(css, pos);
+        if (pos >= css.length || css[pos] === '}') {
+            pos++;
+            break;
+        }
+        pos = parseRule(css, pos, rules, condition);
+    }
+    return pos;
+}
+function parseContainerBlock(css, start, rules) {
+    let pos = start + 10; // skip "@container"
+    pos = skipWhitespace(css, pos);
+    const bracePos = css.indexOf('{', pos);
+    if (bracePos === -1)
+        return skipToClosingBrace(css, pos);
+    let condition = css.substring(pos, bracePos).trim();
+    if (condition.startsWith('(') && !condition.includes(') and (')) {
+        condition = condition.slice(1, -1).trim();
+    }
+    pos = bracePos + 1;
+    while (pos < css.length) {
+        pos = skipWhitespaceAndComments(css, pos);
+        if (pos >= css.length || css[pos] === '}') {
+            pos++;
+            break;
+        }
+        pos = parseRule(css, pos, rules, undefined, undefined, condition);
+    }
+    return pos;
+}
+function parseKeyframesBlock(css, start, keyframes) {
+    let pos = start + 11; // skip "@keyframes "
+    pos = skipWhitespace(css, pos);
+    // Parse name
+    const nameStart = pos;
+    while (pos < css.length && css[pos] !== '{' && css[pos] !== ' ')
+        pos++;
+    const name = css.substring(nameStart, pos).trim();
+    pos = skipWhitespace(css, pos);
+    if (pos >= css.length || css[pos] !== '{')
+        return pos;
+    pos++; // skip {
+    const stops = [];
+    while (pos < css.length) {
+        pos = skipWhitespaceAndComments(css, pos);
+        if (pos >= css.length || css[pos] === '}') {
+            pos++;
+            break;
+        }
+        // Parse offset: "from", "to", or percentage
+        const offsetEnd = css.indexOf('{', pos);
+        if (offsetEnd === -1)
+            break;
+        const offsetStr = css.substring(pos, offsetEnd).trim();
+        let offset = 0;
+        if (offsetStr === 'from')
+            offset = 0;
+        else if (offsetStr === 'to')
+            offset = 1;
+        else if (offsetStr.endsWith('%'))
+            offset = parseFloat(offsetStr) / 100;
+        pos = offsetEnd + 1;
+        // Parse declarations
+        const declarations = [];
+        while (pos < css.length) {
+            pos = skipWhitespace(css, pos);
+            if (pos >= css.length || css[pos] === '}') {
+                pos++;
+                break;
+            }
+            const colonPos = css.indexOf(':', pos);
+            if (colonPos === -1)
+                break;
+            const property = css.substring(pos, colonPos).trim();
+            const valueEnd = findValueEnd(css, colonPos + 1);
+            const value = css.substring(colonPos + 1, valueEnd).trim();
+            declarations.push({ property, value });
+            pos = valueEnd;
+            if (pos < css.length && css[pos] === ';')
+                pos++;
+        }
+        stops.push({ offset, declarations });
+    }
+    if (name && stops.length > 0) {
+        keyframes.set(name, stops);
+    }
+    return pos;
+}
+function parseSupportsBlock(css, start, rules) {
+    let pos = start + 9; // skip "@supports"
+    pos = skipWhitespace(css, pos);
+    const bracePos = css.indexOf('{', pos);
+    if (bracePos === -1)
+        return skipToClosingBrace(css, pos);
+    let condition = css.substring(pos, bracePos).trim();
+    if (condition.startsWith('('))
+        condition = condition.slice(1, -1).trim();
+    pos = bracePos + 1;
+    // Parse rules inside
+    while (pos < css.length) {
+        pos = skipWhitespaceAndComments(css, pos);
+        if (pos >= css.length || css[pos] === '}') {
+            pos++;
+            break;
+        }
+        pos = parseRule(css, pos, rules, undefined, condition);
+    }
+    return pos;
+}
+function parseRule(css, start, rules, media, supports, container) {
+    let pos = start;
+    const selectorEnd = css.indexOf('{', pos);
+    if (selectorEnd === -1)
+        return css.length;
+    const selectorText = css.substring(pos, selectorEnd).trim();
+    const selectors = selectorText.split(',').map(s => s.trim()).filter(Boolean);
+    pos = selectorEnd + 1;
+    const declarations = [];
+    while (pos < css.length) {
+        pos = skipWhitespace(css, pos);
+        if (pos >= css.length || css[pos] === '}') {
+            pos++;
+            break;
+        }
+        const colonPos = css.indexOf(':', pos);
+        if (colonPos === -1)
+            break;
+        const property = css.substring(pos, colonPos).trim();
+        const valueEnd = findValueEnd(css, colonPos + 1);
+        const value = css.substring(colonPos + 1, valueEnd).trim();
+        declarations.push({ property, value });
+        pos = valueEnd;
+        if (pos < css.length && css[pos] === ';')
+            pos++;
+    }
+    if (selectors.length > 0 && declarations.length > 0) {
+        rules.push({ selectors, declarations, media, supports, container });
+    }
+    return pos;
+}
+function skipToClosingBrace(css, pos) {
+    let depth = 0;
+    while (pos < css.length) {
+        if (css[pos] === '{')
+            depth++;
+        else if (css[pos] === '}') {
+            if (depth === 0)
+                return pos + 1;
+            depth--;
+        }
+        pos++;
+    }
+    return pos;
+}
+function findValueEnd(css, start) {
+    let pos = start;
+    let depth = 0;
+    while (pos < css.length) {
+        const ch = css[pos];
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        else if (depth === 0 && (ch === ';' || ch === '}'))
+            return pos;
+        pos++;
+    }
+    return pos;
+}
+function skipWhitespace(css, pos) {
+    while (pos < css.length && /\s/.test(css[pos]))
+        pos++;
+    return pos;
+}
+function skipWhitespaceAndComments(css, pos) {
+    while (pos < css.length) {
+        pos = skipWhitespace(css, pos);
+        if (pos + 1 < css.length && css[pos] === '/' && css[pos + 1] === '*') {
+            const end = css.indexOf('*/', pos + 2);
+            pos = end === -1 ? css.length : end + 2;
+        }
+        else {
+            break;
+        }
+    }
+    return pos;
+}

package/dist/src/css/selector.d.ts

@@ -0,0 +1,17 @@
+import { TermNode } from '../renderer/node.js';
+export interface ParsedSelector {
+    tag?: string;
+    id?: string;
+    classes: string[];
+    pseudo?: string;
+    pseudoArg?: string;
+    attributes: AttrSelector[];
+    universal?: boolean;
+}
+interface AttrSelector {
+    name: string;
+    value?: string;
+}
+export declare function parseSelector(selector: string): ParsedSelector;
+export declare function matchesSelector(node: TermNode, selector: string): boolean;
+export {};

package/dist/src/css/selector.js

@@ -0,0 +1,272 @@
+export function parseSelector(selector) {
+    const result = { classes: [], attributes: [] };
+    let pos = 0;
+    // Universal selector
+    if (pos < selector.length && selector[pos] === '*') {
+        result.universal = true;
+        pos++;
+    }
+    // Tag name
+    if (pos < selector.length && /[a-zA-Z]/.test(selector[pos])) {
+        const start = pos;
+        while (pos < selector.length && /[a-zA-Z0-9-]/.test(selector[pos]))
+            pos++;
+        result.tag = selector.substring(start, pos);
+    }
+    while (pos < selector.length) {
+        if (selector[pos] === '#') {
+            pos++;
+            const start = pos;
+            while (pos < selector.length && /[a-zA-Z0-9_-]/.test(selector[pos]))
+                pos++;
+            result.id = selector.substring(start, pos);
+        }
+        else if (selector[pos] === '.') {
+            pos++;
+            const start = pos;
+            while (pos < selector.length && /[a-zA-Z0-9_-]/.test(selector[pos]))
+                pos++;
+            result.classes.push(selector.substring(start, pos));
+        }
+        else if (selector[pos] === '[') {
+            pos++;
+            const attr = parseAttrSelector(selector, pos);
+            result.attributes.push(attr.selector);
+            pos = attr.end;
+        }
+        else if (selector[pos] === ':') {
+            pos++;
+            const start = pos;
+            while (pos < selector.length && /[a-zA-Z0-9_-]/.test(selector[pos]))
+                pos++;
+            const name = selector.substring(start, pos);
+            // Functional pseudo-class: :not(...), :nth-child(...)
+            if (pos < selector.length && selector[pos] === '(') {
+                pos++;
+                const argStart = pos;
+                let depth = 1;
+                while (pos < selector.length && depth > 0) {
+                    if (selector[pos] === '(')
+                        depth++;
+                    else if (selector[pos] === ')')
+                        depth--;
+                    if (depth > 0)
+                        pos++;
+                }
+                result.pseudoArg = selector.substring(argStart, pos).trim();
+                pos++; // skip closing )
+            }
+            result.pseudo = name;
+        }
+        else {
+            pos++;
+        }
+    }
+    return result;
+}
+function parseAttrSelector(selector, pos) {
+    const nameStart = pos;
+    while (pos < selector.length && selector[pos] !== '=' && selector[pos] !== ']')
+        pos++;
+    const name = selector.substring(nameStart, pos).trim();
+    if (pos < selector.length && selector[pos] === '=') {
+        pos++; // skip =
+        let value = '';
+        if (pos < selector.length && (selector[pos] === '"' || selector[pos] === "'")) {
+            const quote = selector[pos];
+            pos++;
+            const valStart = pos;
+            while (pos < selector.length && selector[pos] !== quote)
+                pos++;
+            value = selector.substring(valStart, pos);
+            pos++; // skip closing quote
+        }
+        while (pos < selector.length && selector[pos] !== ']')
+            pos++;
+        pos++; // skip ]
+        return { selector: { name, value }, end: pos };
+    }
+    while (pos < selector.length && selector[pos] !== ']')
+        pos++;
+    pos++; // skip ]
+    return { selector: { name }, end: pos };
+}
+export function matchesSelector(node, selector) {
+    if (node.nodeType !== 'element')
+        return false;
+    const trimmed = selector.trim();
+    if (trimmed === ':root')
+        return node.parent === null;
+    const parts = splitIntoParts(trimmed);
+    if (parts.length === 0)
+        return false;
+    return matchParts(node, parts, parts.length - 1);
+}
+function splitIntoParts(selector) {
+    const parts = [];
+    const tokens = tokenizeSelector(selector);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token === '>' || token === ' ' || token === '+' || token === '~')
+            continue;
+        let combinator = '';
+        if (i > 0) {
+            const prev = tokens[i - 1];
+            if (prev === '>' || prev === '+' || prev === '~')
+                combinator = prev;
+            else
+                combinator = ' ';
+        }
+        parts.push({ selector: parseSelector(token), combinator });
+    }
+    return parts;
+}
+function tokenizeSelector(selector) {
+    const tokens = [];
+    let pos = 0;
+    let current = '';
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    while (pos < selector.length) {
+        const ch = selector[pos];
+        if (ch === '[')
+            bracketDepth++;
+        if (ch === ']')
+            bracketDepth--;
+        if (ch === '(')
+            parenDepth++;
+        if (ch === ')')
+            parenDepth--;
+        if (bracketDepth > 0 || parenDepth > 0) {
+            current += ch;
+            pos++;
+            continue;
+        }
+        if (ch === '>' || ch === '+' || ch === '~') {
+            if (current.trim())
+                tokens.push(current.trim());
+            tokens.push(ch);
+            current = '';
+            pos++;
+        }
+        else if (ch === ' ') {
+            if (current.trim()) {
+                tokens.push(current.trim());
+                let next = pos + 1;
+                while (next < selector.length && selector[next] === ' ')
+                    next++;
+                if (next < selector.length && !'> +~'.includes(selector[next])) {
+                    tokens.push(' ');
+                }
+            }
+            current = '';
+            pos++;
+        }
+        else {
+            current += ch;
+            pos++;
+        }
+    }
+    if (current.trim())
+        tokens.push(current.trim());
+    return tokens;
+}
+function matchParts(node, parts, index) {
+    const part = parts[index];
+    if (!matchesParsed(node, part.selector))
+        return false;
+    if (index === 0)
+        return true;
+    const combinator = parts[index].combinator;
+    if (combinator === '>') {
+        if (!node.parent || node.parent.nodeType !== 'element')
+            return false;
+        return matchParts(node.parent, parts, index - 1);
+    }
+    if (combinator === '+') {
+        const prev = getPreviousElementSibling(node);
+        if (!prev)
+            return false;
+        return matchParts(prev, parts, index - 1);
+    }
+    if (combinator === '~') {
+        if (!node.parent)
+            return false;
+        const siblings = node.parent.children;
+        const myIndex = siblings.indexOf(node);
+        for (let i = myIndex - 1; i >= 0; i--) {
+            if (siblings[i].nodeType === 'element' && matchParts(siblings[i], parts, index - 1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Descendant: any ancestor
+    let ancestor = node.parent;
+    while (ancestor) {
+        if (ancestor.nodeType === 'element' && matchParts(ancestor, parts, index - 1)) {
+            return true;
+        }
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
+function getPreviousElementSibling(node) {
+    if (!node.parent)
+        return null;
+    const siblings = node.parent.children;
+    const idx = siblings.indexOf(node);
+    for (let i = idx - 1; i >= 0; i--) {
+        if (siblings[i].nodeType === 'element')
+            return siblings[i];
+    }
+    return null;
+}
+function matchesParsed(node, parsed) {
+    if (parsed.tag && node.tag !== parsed.tag)
+        return false;
+    if (parsed.id && node.attributes.get('id') !== parsed.id)
+        return false;
+    const nodeClasses = node.classes;
+    for (const cls of parsed.classes) {
+        if (!nodeClasses.has(cls))
+            return false;
+    }
+    for (const attr of parsed.attributes) {
+        if (!node.attributes.has(attr.name))
+            return false;
+        if (attr.value !== undefined && node.attributes.get(attr.name) !== attr.value)
+            return false;
+    }
+    if (parsed.pseudo) {
+        if (!matchesPseudo(node, parsed.pseudo, parsed.pseudoArg))
+            return false;
+    }
+    return true;
+}
+function matchesPseudo(node, pseudo, arg) {
+    switch (pseudo) {
+        case 'root': return node.parent === null;
+        case 'focus': return node.attributes.get('data-focused') === 'true';
+        case 'hover': return node.attributes.get('data-hovered') === 'true';
+        case 'first-child': return isFirstChild(node);
+        case 'last-child': return isLastChild(node);
+        case 'not':
+            if (!arg)
+                return false;
+            return !matchesParsed(node, parseSelector(arg));
+        default: return false;
+    }
+}
+function isFirstChild(node) {
+    if (!node.parent)
+        return false;
+    const siblings = node.parent.children.filter(c => c.nodeType === 'element');
+    return siblings[0] === node;
+}
+function isLastChild(node) {
+    if (!node.parent)
+        return false;
+    const siblings = node.parent.children.filter(c => c.nodeType === 'element');
+    return siblings[siblings.length - 1] === node;
+}

package/dist/src/css/specificity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute CSS specificity as [id, class, element] tuple.
+ * Higher tuple wins. Equal specificity: later rule wins.
+ */
+export declare function computeSpecificity(selector: string): [number, number, number];
+/** Compare two specificity tuples. Returns positive if a wins, negative if b wins, 0 if equal. */
+export declare function compareSpecificity(a: [number, number, number], b: [number, number, number]): number;