@master/css-engine 2.0.0-rc.70

package/dist/emitted-globals.d.ts

@@ -0,0 +1,4 @@
+export interface MasterCSSEmittedGlobals {
+    variables?: Record<string, number>;
+    animations?: Record<string, number>;
+}

package/dist/emitted-globals.mjs

@@ -0,0 +1 @@
+

package/dist/hydration-manifest.d.ts

@@ -0,0 +1,4 @@
+import type MasterCSS from './core';
+import type { MasterCSSHydrationManifest } from '@master/css-schema/hydration-manifest';
+export default function createHydrationManifest(css: MasterCSS): MasterCSSHydrationManifest;
+export type { MasterCSSGeneratedRuleIR, MasterCSSHydrationManifest } from '@master/css-schema/hydration-manifest';

package/dist/hydration-manifest.mjs

@@ -0,0 +1,61 @@
+import { Utility } from './utility.mjs';
+import { getRuleSortTier } from './utils/compare-rule-priority.mjs';
+
+function serializeRule(className, rule) {
+    const nodes = rule.nodes?.map((node)=>({
+            text: node.text
+        }));
+    return {
+        className,
+        key: rule.key,
+        layer: rule.layerName,
+        type: rule.type,
+        sortTier: getRuleSortTier(rule),
+        priority: {
+            ...rule.priority.features?.length ? {
+                features: rule.priority.features.map((feature)=>[
+                        ...feature
+                    ])
+            } : {},
+            selector: rule.priority.selector
+        },
+        text: rule.text,
+        ...nodes?.length ? {
+            nodes
+        } : {},
+        selectorText: rule.selectorText,
+        ...rule.variableNames?.size ? {
+            variableNames: [
+                ...rule.variableNames
+            ]
+        } : {},
+        ...rule.animationNames?.size ? {
+            animationNames: [
+                ...rule.animationNames
+            ]
+        } : {}
+    };
+}
+function createHydrationManifest(css) {
+    const classNameByRule = new WeakMap();
+    for (const [className, rules] of css.classUtilities){
+        for (const rule of rules){
+            classNameByRule.set(rule, className);
+        }
+    }
+    const hydrationManifest = {
+        version: 1,
+        rules: []
+    };
+    for (const layer of css.getUtilityLayers()){
+        for (const rule of layer.rules){
+            if (!(rule instanceof Utility)) continue;
+            const className = classNameByRule.get(rule);
+            if (!className) continue;
+            hydrationManifest.rules.push(serializeRule(className, rule));
+        }
+    }
+    return hydrationManifest;
+}
+
+export { createHydrationManifest as default };

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { default as MasterCSS, default } from './core';
+export type { CompiledUtility, MasterCSSCreateOptions, MasterCSSOptions, NativeCSSDeclaration, NativeCSSDeclarationMatcher } from './core';
+export { Rule } from './rule';
+export { default as Layer } from './layer';
+export { default as ThemeLayer } from './theme-layer';
+export { default as UtilityLayer } from './utility-layer';
+export { default as NonLayer } from './non-layer';
+export { default as VariableRule } from './variable-rule';
+export { default as AnimationRule } from './animation-rule';
+export { default as compareRulePriority } from './utils/compare-rule-priority';
+export { default as createHydrationManifest } from './hydration-manifest';
+export { collectAnimationNamesFromDeclaration } from './utils/collect-animation-names';
+export { builtinKeyAliases } from './key-aliases';
+export type { MasterCSSBuiltinKeyAliases } from './key-aliases';
+export { builtinNamespaces, builtinNamespaceRef, builtinNamespaceSet } from './namespaces';
+export type { MasterCSSBuiltinNamespace, MasterCSSBuiltinNamespaceRef } from './namespaces';
+export { builtinNativeValueNamespaces } from './native-value-namespaces';
+export type { MasterCSSBuiltinNativeValueNamespace, MasterCSSBuiltinNativeValueNamespaces } from './native-value-namespaces';
+export * from '@master/css-schema/manifest';
+export type * from './emitted-globals';
+export type { Utility as GeneratedRule } from './utility';
+export type { MasterCSSGeneratedRuleIR, MasterCSSHydrationManifest } from '@master/css-schema/hydration-manifest';

package/dist/index.mjs

@@ -0,0 +1,15 @@
+export { default as MasterCSS, default } from './core.mjs';
+export { Rule } from './rule.mjs';
+export { default as Layer } from './layer.mjs';
+export { default as ThemeLayer } from './theme-layer.mjs';
+export { default as UtilityLayer } from './utility-layer.mjs';
+export { default as NonLayer } from './non-layer.mjs';
+export { default as VariableRule } from './variable-rule.mjs';
+export { default as AnimationRule } from './animation-rule.mjs';
+export { default as compareRulePriority } from './utils/compare-rule-priority.mjs';
+export { default as createHydrationManifest } from './hydration-manifest.mjs';
+export { collectAnimationNamesFromDeclaration } from './utils/collect-animation-names.mjs';
+export { builtinKeyAliases } from './key-aliases.mjs';
+export { builtinNamespaceRef, builtinNamespaceSet, builtinNamespaces } from './namespaces.mjs';
+export { builtinNativeValueNamespaces } from './native-value-namespaces.mjs';
+export * from '@master/css-schema/manifest';

package/dist/key-aliases.d.ts

@@ -0,0 +1,4 @@
+export type MasterCSSBuiltinKeyAliases = Readonly<Record<string, string>>;
+declare const keyAliases: MasterCSSBuiltinKeyAliases;
+export default keyAliases;
+export { keyAliases as builtinKeyAliases };

package/dist/key-aliases.mjs

@@ -0,0 +1,95 @@
+const keyAliases = Object.freeze({
+    'fg': 'color',
+    'bg': 'background',
+    'gap-x': 'column-gap',
+    'gap-y': 'row-gap',
+    'grid-col': 'grid-column',
+    'grid-col-end': 'grid-column-end',
+    'grid-col-start': 'grid-column-start',
+    'b': 'border',
+    'bb': 'border-bottom',
+    'bl': 'border-left',
+    'br': 'border-right',
+    'bt': 'border-top',
+    'bx': 'border-inline',
+    'by': 'border-block',
+    'h': 'height',
+    'ix': 'inset-inline',
+    'ixe': 'inset-inline-end',
+    'ixs': 'inset-inline-start',
+    'iy': 'inset-block',
+    'iye': 'inset-block-end',
+    'iys': 'inset-block-start',
+    'leading': 'line-height',
+    'm': 'margin',
+    'max': 'max-size',
+    'max-h': 'max-height',
+    'max-size-x': 'max-inline-size',
+    'max-size-y': 'max-block-size',
+    'max-w': 'max-width',
+    'mb': 'margin-bottom',
+    'min': 'min-size',
+    'min-h': 'min-height',
+    'min-size-x': 'min-inline-size',
+    'min-size-y': 'min-block-size',
+    'min-w': 'min-width',
+    'ml': 'margin-left',
+    'mr': 'margin-right',
+    'mt': 'margin-top',
+    'mx': 'margin-inline',
+    'mxe': 'margin-inline-end',
+    'mxs': 'margin-inline-start',
+    'my': 'margin-block',
+    'mye': 'margin-block-end',
+    'mys': 'margin-block-start',
+    'p': 'padding',
+    'pb': 'padding-bottom',
+    'pl': 'padding-left',
+    'pr': 'padding-right',
+    'pt': 'padding-top',
+    'px': 'padding-inline',
+    'pxe': 'padding-inline-end',
+    'pxs': 'padding-inline-start',
+    'py': 'padding-block',
+    'pye': 'padding-block-end',
+    'pys': 'padding-block-start',
+    'r': 'border-radius',
+    'rbl': 'border-bottom-left-radius',
+    'rbr': 'border-bottom-right-radius',
+    'rtl': 'border-top-left-radius',
+    'rtr': 'border-top-right-radius',
+    'scroll-m': 'scroll-margin',
+    'scroll-mb': 'scroll-margin-bottom',
+    'scroll-ml': 'scroll-margin-left',
+    'scroll-mr': 'scroll-margin-right',
+    'scroll-mt': 'scroll-margin-top',
+    'scroll-mx': 'scroll-margin-inline',
+    'scroll-mxe': 'scroll-margin-inline-end',
+    'scroll-mxs': 'scroll-margin-inline-start',
+    'scroll-my': 'scroll-margin-block',
+    'scroll-mye': 'scroll-margin-block-end',
+    'scroll-mys': 'scroll-margin-block-start',
+    'scroll-p': 'scroll-padding',
+    'scroll-pb': 'scroll-padding-bottom',
+    'scroll-pl': 'scroll-padding-left',
+    'scroll-pr': 'scroll-padding-right',
+    'scroll-pt': 'scroll-padding-top',
+    'scroll-px': 'scroll-padding-inline',
+    'scroll-pxe': 'scroll-padding-inline-end',
+    'scroll-pxs': 'scroll-padding-inline-start',
+    'scroll-py': 'scroll-padding-block',
+    'scroll-pye': 'scroll-padding-block-end',
+    'scroll-pys': 'scroll-padding-block-start',
+    'shadow': 'box-shadow',
+    'size-x': 'inline-size',
+    'size-y': 'block-size',
+    'line-clamp': '-webkit-line-clamp',
+    'text-fill-color': '-webkit-text-fill-color',
+    'text-stroke-color': '-webkit-text-stroke-color',
+    'text-stroke-width': '-webkit-text-stroke-width',
+    'tracking': 'letter-spacing',
+    'w': 'width',
+    'z': 'z-index'
+});
+
+export { keyAliases as builtinKeyAliases, keyAliases as default };

package/dist/layer.d.ts

@@ -0,0 +1,17 @@
+import { Rule } from './rule';
+import MasterCSS from './core';
+import VariableRule from './variable-rule';
+export default class Layer {
+    name: string;
+    css: MasterCSS;
+    readonly rules: (Rule | VariableRule)[];
+    readonly tokenCounts: Map<string, number>;
+    constructor(name: string, css: MasterCSS);
+    attach(): void;
+    detach(): void;
+    get(key: string): Rule | VariableRule | undefined;
+    insert(rule: Rule | VariableRule, index?: number): number | undefined;
+    delete(key: string): Rule | VariableRule | undefined;
+    reset(): void;
+    get text(): string;
+}

package/dist/layer.mjs

@@ -0,0 +1,78 @@
+const ruleMaps = new WeakMap();
+function getRuleMap(layer) {
+    let ruleMap = ruleMaps.get(layer);
+    if (!ruleMap) {
+        ruleMap = new Map();
+        ruleMaps.set(layer, ruleMap);
+    }
+    return ruleMap;
+}
+function syncRuleMap(layer) {
+    const ruleMap = getRuleMap(layer);
+    if (ruleMap.size !== layer.rules.length) {
+        ruleMap.clear();
+        for (const rule of layer.rules){
+            ruleMap.set(rule.key, rule);
+        }
+    }
+    return ruleMap;
+}
+class Layer {
+    name;
+    css;
+    rules = [];
+    tokenCounts = new Map();
+    constructor(name, css){
+        this.name = name;
+        this.css = css;
+    }
+    attach() {
+        this.css.rules.push(this);
+    }
+    detach() {
+        this.css.rules.splice(this.css.rules.indexOf(this), 1);
+    }
+    get(key) {
+        return syncRuleMap(this).get(key);
+    }
+    insert(rule, index = this.rules.length) {
+        const ruleMap = syncRuleMap(this);
+        if (ruleMap.has(rule.key)) return;
+        this.rules.splice(index, 0, rule);
+        ruleMap.set(rule.key, rule);
+        // should attach after inserting, because this.text is possibly empty
+        if (!this.css.rules.includes(this)) {
+            this.attach();
+        }
+        return index;
+    }
+    delete(key) {
+        const ruleMap = syncRuleMap(this);
+        const deletedRule = ruleMap.get(key);
+        if (!deletedRule) return;
+        const index = this.rules.indexOf(deletedRule);
+        if (index === -1) return;
+        this.rules.splice(index, 1);
+        ruleMap.delete(key);
+        if (this.rules.length === 0) {
+            this.detach();
+        }
+        return deletedRule;
+    }
+    reset() {
+        this.rules.length = 0;
+        const indexOfLayer = this.css.rules.indexOf(this);
+        if (indexOfLayer !== -1) {
+            this.css.rules.splice(indexOfLayer, 1);
+        }
+        this.tokenCounts.clear();
+        getRuleMap(this).clear();
+    }
+    get text() {
+        const ruleText = this.rules.map(({ text })=>text).join('');
+        if (!ruleText) return '';
+        return '@layer ' + this.name + '{' + ruleText + '}';
+    }
+}
+
+export { Layer as default };

package/dist/namespaces.d.ts

@@ -0,0 +1,5 @@
+export declare const builtinNamespaces: readonly ["animate", "breakpoint", "color", "color-line", "color-text", "container", "content", "duration", "easing", "font", "font-family", "font-feature", "font-size", "font-weight", "leading", "order", "radius", "shadow", "spacing", "tracking"];
+export type MasterCSSBuiltinNamespace = typeof builtinNamespaces[number];
+export type MasterCSSBuiltinNamespaceRef = `~${MasterCSSBuiltinNamespace}` | `=${MasterCSSBuiltinNamespace}`;
+export declare function builtinNamespaceRef(namespace: MasterCSSBuiltinNamespace, exact?: boolean): MasterCSSBuiltinNamespaceRef;
+export declare const builtinNamespaceSet: ReadonlySet<string>;

package/dist/namespaces.mjs

@@ -0,0 +1,28 @@
+const builtinNamespaces = Object.freeze([
+    'animate',
+    'breakpoint',
+    'color',
+    'color-line',
+    'color-text',
+    'container',
+    'content',
+    'duration',
+    'easing',
+    'font',
+    'font-family',
+    'font-feature',
+    'font-size',
+    'font-weight',
+    'leading',
+    'order',
+    'radius',
+    'shadow',
+    'spacing',
+    'tracking'
+]);
+function builtinNamespaceRef(namespace, exact = false) {
+    return `${exact ? '=' : '~'}${namespace}`;
+}
+const builtinNamespaceSet = new Set(builtinNamespaces);
+
+export { builtinNamespaceRef, builtinNamespaceSet, builtinNamespaces };

package/dist/native-value-namespaces.d.ts

@@ -0,0 +1,9 @@
+import { type MasterCSSBuiltinNamespaceRef } from './namespaces';
+export interface MasterCSSBuiltinNativeValueNamespace {
+    readonly properties: readonly string[];
+    readonly variableAliasRefs: readonly MasterCSSBuiltinNamespaceRef[];
+}
+export type MasterCSSBuiltinNativeValueNamespaces = readonly MasterCSSBuiltinNativeValueNamespace[];
+declare const nativeValueNamespaces: MasterCSSBuiltinNativeValueNamespaces;
+export default nativeValueNamespaces;
+export { nativeValueNamespaces as builtinNativeValueNamespaces };