@roblawn/devtool-runtime 0.1.0-alpha.0

package/dist/theme-contract/ops/coreOps.js

@@ -0,0 +1,748 @@
+import { defineDelegate } from './delegateValidation.types.js';
+import { Emit } from './emitters.js';
+function defineCoreOps(config) {
+    return config;
+}
+const CORE_DESIGN_OP_CONFIG_RAW = {
+    m: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('m', v),
+    },
+    mt: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin-top',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('mt', v),
+    },
+    mr: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin-right',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('mr', v),
+    },
+    mb: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin-bottom',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('mb', v),
+    },
+    ml: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin-left',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('ml', v),
+    },
+    mx: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin-x',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('mx', v),
+    },
+    my: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'margin-y',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('my', v),
+    },
+    p: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('p', v),
+    },
+    pt: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding-top',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('pt', v),
+    },
+    pr: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding-right',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('pr', v),
+    },
+    pb: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding-bottom',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('pb', v),
+    },
+    pl: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding-left',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('pl', v),
+    },
+    px: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding-x',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('px', v),
+    },
+    py: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'padding-y',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('py', v),
+    },
+    gap: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'gap',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('gap', v),
+    },
+    gapx: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'gap-x',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('gap-x', v),
+    },
+    gapy: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'gap-y',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('gap-y', v),
+    },
+    xspace: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'gap-x',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('space-x', v),
+    },
+    yspace: {
+        tokenFamily: 'spacing',
+        authoringEffect: 'gap-y',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('space-y', v),
+    },
+    w: {
+        tokenFamily: 'container',
+        authoringEffect: 'width',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.containerSize('w', v),
+    },
+    h: {
+        tokenFamily: 'container',
+        authoringEffect: 'height',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.containerSize('h', v),
+    },
+    minW: {
+        tokenFamily: 'container',
+        authoringEffect: 'min-width',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.containerSize('min-w', v),
+    },
+    minH: {
+        tokenFamily: 'container',
+        authoringEffect: 'min-height',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.containerSize('min-h', v),
+    },
+    maxW: {
+        tokenFamily: 'container',
+        authoringEffect: 'max-width',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.containerSize('max-w', v),
+    },
+    maxH: {
+        tokenFamily: 'container',
+        authoringEffect: 'max-height',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.containerSize('max-h', v),
+    },
+    contentWidth: {
+        tokenFamily: 'container',
+        authoringEffect: 'max-width',
+        responsive: true,
+        addNoneasOmit: true,
+        resolve: (v) => Emit.contentWidth(v),
+    },
+    cols: {
+        tokenFamily: 'colCount',
+        authoringEffect: 'element',
+        authoringValue: {
+            kind: 'number',
+            min: 1,
+            max: 12,
+            step: 1,
+        },
+        resolve: (v) => Emit.prefix('grid-cols', v),
+    },
+    rows: {
+        tokenFamily: 'rowCount',
+        authoringEffect: 'element',
+        authoringValue: {
+            kind: 'number',
+            min: 1,
+            max: 6,
+            step: 1,
+        },
+        resolve: (v) => Emit.prefix('grid-rows', v),
+    },
+    colSpan: {
+        tokenFamily: 'colCount',
+        authoringEffect: 'element',
+        authoringValue: {
+            kind: 'number',
+            min: 1,
+            max: 12,
+            step: 1,
+        },
+        resolve: (v) => Emit.prefix('col-span', v),
+    },
+    rowSpan: {
+        tokenFamily: 'rowCount',
+        authoringEffect: 'element',
+        authoringValue: {
+            kind: 'number',
+            min: 1,
+            max: 6,
+            step: 1,
+        },
+        resolve: (v) => Emit.prefix('row-span', v),
+    },
+    rounded: {
+        tokenFamily: 'radius',
+        authoringEffect: 'radius',
+        resolve: (v) => Emit.rounded('rounded', v),
+    },
+    roundedT: {
+        tokenFamily: 'radius',
+        authoringEffect: 'radius-top',
+        resolve: (v) => Emit.rounded('rounded-t', v),
+    },
+    roundedR: {
+        tokenFamily: 'radius',
+        authoringEffect: 'radius-right',
+        resolve: (v) => Emit.rounded('rounded-r', v),
+    },
+    roundedB: {
+        tokenFamily: 'radius',
+        authoringEffect: 'radius-bottom',
+        resolve: (v) => Emit.rounded('rounded-b', v),
+    },
+    roundedL: {
+        tokenFamily: 'radius',
+        authoringEffect: 'radius-left',
+        resolve: (v) => Emit.rounded('rounded-l', v),
+    },
+    border: {
+        tokenFamily: 'border',
+        authoringEffect: 'border',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.borderComposite(v),
+    },
+    borderT: {
+        tokenFamily: 'border',
+        authoringEffect: 'border-top',
+        resolve: (v) => Emit.borderCompositeSide('t', v),
+        delegate: defineDelegate('border', {
+            width: 'borderWidthT',
+        }),
+    },
+    borderR: {
+        tokenFamily: 'border',
+        authoringEffect: 'border-right',
+        resolve: (v) => Emit.borderCompositeSide('r', v),
+        delegate: defineDelegate('border', {
+            width: 'borderWidthR',
+        }),
+    },
+    borderB: {
+        tokenFamily: 'border',
+        authoringEffect: 'border-bottom',
+        resolve: (v) => Emit.borderCompositeSide('b', v),
+        delegate: defineDelegate('border', {
+            width: 'borderWidthB',
+        }),
+    },
+    borderL: {
+        tokenFamily: 'border',
+        authoringEffect: 'border-left',
+        resolve: (v) => Emit.borderCompositeSide('l', v),
+        delegate: defineDelegate('border', {
+            width: 'borderWidthL',
+        }),
+    },
+    borderWidth: {
+        tokenFamily: 'borderWidth',
+        authoringEffect: 'border',
+        addNoneasOmit: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.5,
+        },
+        private: true,
+        resolve: (v) => Emit.border(v),
+    },
+    borderWidthT: {
+        tokenFamily: 'borderWidth',
+        authoringEffect: 'border-top',
+        addNoneasOmit: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.5,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (!Number.isFinite(numericValue)) {
+                return Emit.isEmpty(v) ? 'border-t' : `border-t-(length:--border-${String(v)})`;
+            }
+            if (Number.isInteger(numericValue)) {
+                return `border-t-${numericValue}`;
+            }
+            return `border-t-[${numericValue}px]`;
+        },
+    },
+    borderWidthR: {
+        tokenFamily: 'borderWidth',
+        authoringEffect: 'border-right',
+        addNoneasOmit: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.5,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (!Number.isFinite(numericValue)) {
+                return Emit.isEmpty(v) ? 'border-r' : `border-r-(length:--border-${String(v)})`;
+            }
+            if (Number.isInteger(numericValue)) {
+                return `border-r-${numericValue}`;
+            }
+            return `border-r-[${numericValue}px]`;
+        },
+    },
+    borderWidthB: {
+        tokenFamily: 'borderWidth',
+        authoringEffect: 'border-bottom',
+        addNoneasOmit: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.5,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (!Number.isFinite(numericValue)) {
+                return Emit.isEmpty(v) ? 'border-b' : `border-b-(length:--border-${String(v)})`;
+            }
+            if (Number.isInteger(numericValue)) {
+                return `border-b-${numericValue}`;
+            }
+            return `border-b-[${numericValue}px]`;
+        },
+    },
+    borderWidthL: {
+        tokenFamily: 'borderWidth',
+        authoringEffect: 'border-left',
+        addNoneasOmit: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.5,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (!Number.isFinite(numericValue)) {
+                return Emit.isEmpty(v) ? 'border-l' : `border-l-(length:--border-${String(v)})`;
+            }
+            if (Number.isInteger(numericValue)) {
+                return `border-l-${numericValue}`;
+            }
+            return `border-l-[${numericValue}px]`;
+        },
+    },
+    borderColor: {
+        tokenFamily: 'color',
+        authoringEffect: 'border',
+        addNoneasOmit: true,
+        private: true,
+        resolve: (v) => Emit.prefix('border', v),
+    },
+    borderStyle: {
+        tokenFamily: 'borderStyle',
+        authoringEffect: 'border',
+        private: true,
+        resolve: (v) => (Emit.isEmpty(v) ? 'border-solid' : `border-${String(v)}`),
+    },
+    divide: {
+        tokenFamily: 'border',
+        authoringEffect: 'divide',
+        resolve: (v) => Emit.divideComposite(v),
+        delegate: defineDelegate('border', {
+            color: 'divideColor',
+            width: 'divideWidth',
+            style: 'divideStyle',
+        }),
+    },
+    divideColor: {
+        tokenFamily: 'color',
+        authoringEffect: 'divide',
+        addNoneasOmit: true,
+        private: true,
+        resolve: (v) => Emit.prefix('divide', v),
+    },
+    divideWidth: {
+        tokenFamily: 'borderWidth',
+        authoringEffect: 'divide-x',
+        addNoneasOmit: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.5,
+        },
+        private: true,
+        resolve: (v) => Emit.divideBorder(v),
+    },
+    divideStyle: {
+        tokenFamily: 'borderStyle',
+        authoringEffect: 'divide',
+        private: true,
+        resolve: (v) => (Emit.isEmpty(v) ? 'divide-solid' : `divide-${String(v)}`),
+    },
+    bg: {
+        tokenFamily: 'color',
+        authoringEffect: 'background',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('bg', v),
+    },
+    textColor: {
+        tokenFamily: 'color',
+        authoringEffect: 'text',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.prefix('text', v),
+    },
+    opacity: {
+        tokenFamily: 'opacity',
+        authoringEffect: 'element',
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            max: 100,
+            step: 1,
+        },
+        resolve: (v) => Emit.prefix('opacity', v),
+    },
+    textStyle: {
+        tokenFamily: 'text',
+        authoringEffect: 'text-style',
+        responsive: true,
+        resolve: (v) => Emit.prefix('text-style', v),
+    },
+    titleStyle: {
+        tokenFamily: 'title',
+        authoringEffect: 'text-style',
+        responsive: true,
+        resolve: (v) => Emit.prefix('title-style', v),
+    },
+    textAlign: {
+        tokenFamily: 'textAlign',
+        authoringEffect: 'text-alignment',
+        addNoneasOmit: true,
+        responsive: true,
+        resolve: (v) => Emit.prefix('text', v),
+    },
+    textSize: {
+        tokenFamily: 'textSize',
+        authoringEffect: 'text',
+        responsive: true,
+        authoringValue: {
+            kind: 'number',
+            min: 1,
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (Number.isFinite(numericValue)) {
+                return `text-[${numericValue}px]`;
+            }
+            return Emit.prefix('text', v);
+        },
+    },
+    textTransform: {
+        tokenFamily: 'textTransform',
+        authoringEffect: 'text',
+        responsive: false,
+        addNoneasOmit: true,
+        resolve: (v) => (Emit.isEmpty(v) ? '' : v),
+    },
+    fontWeight: {
+        tokenFamily: 'fontWeight',
+        authoringEffect: 'text',
+        responsive: true,
+        private: true,
+        resolve: (v) => (Emit.isEmpty(v) ? '' : `font-${String(v)}`),
+    },
+    fontFamily: {
+        tokenFamily: 'font',
+        authoringEffect: 'text',
+        responsive: true,
+        private: true,
+        resolve: (v) => (Emit.isEmpty(v) ? '' : `font-${String(v)}`),
+    },
+    leading: {
+        tokenFamily: 'leading',
+        authoringEffect: 'text',
+        responsive: true,
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 0.001,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (Number.isFinite(numericValue)) {
+                return `leading-[${numericValue}]`;
+            }
+            return Emit.prefix('leading', v);
+        },
+    },
+    tracking: {
+        tokenFamily: 'tracking',
+        authoringEffect: 'text',
+        responsive: true,
+        authoringValue: {
+            kind: 'number',
+            step: 0.001,
+        },
+        private: true,
+        resolve: (v) => {
+            const numericValue = Number(String(v));
+            if (Number.isFinite(numericValue)) {
+                return `tracking-[${numericValue}em]`;
+            }
+            return Emit.prefix('tracking', v);
+        },
+    },
+    shadow: {
+        tokenFamily: 'shadow',
+        authoringEffect: 'shadow',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.shadow(v),
+    },
+    shadowCompose: {
+        tokenFamily: 'shadowCompose',
+        authoringEffect: 'shadow',
+        private: true,
+        resolve: (v) => Emit.shadowCompose(v),
+    },
+    shadowX1: {
+        tokenFamily: 'shadowOffset',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-x-1', 'shadow-offset', v),
+    },
+    shadowY1: {
+        tokenFamily: 'shadowOffset',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-y-1', 'shadow-offset', v),
+    },
+    shadowBlur1: {
+        tokenFamily: 'shadowBlur',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-blur-1', 'shadow-blur', v),
+    },
+    shadowSpread1: {
+        tokenFamily: 'shadowSpread',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-spread-1', 'shadow-spread', v),
+    },
+    shadowOpacity1: {
+        tokenFamily: 'shadowOpacity',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            max: 100,
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowOpacityVar('shadow-opacity-1', v),
+    },
+    shadowX2: {
+        tokenFamily: 'shadowOffset',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-x-2', 'shadow-offset', v),
+    },
+    shadowY2: {
+        tokenFamily: 'shadowOffset',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-y-2', 'shadow-offset', v),
+    },
+    shadowBlur2: {
+        tokenFamily: 'shadowBlur',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-blur-2', 'shadow-blur', v),
+    },
+    shadowSpread2: {
+        tokenFamily: 'shadowSpread',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowTokenVar('shadow-spread-2', 'shadow-spread', v),
+    },
+    shadowOpacity2: {
+        tokenFamily: 'shadowOpacity',
+        authoringEffect: 'shadow',
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            max: 100,
+            step: 1,
+        },
+        private: true,
+        resolve: (v) => Emit.shadowOpacityVar('shadow-opacity-2', v),
+    },
+    shadowColor: {
+        tokenFamily: 'color',
+        authoringEffect: 'shadow',
+        resolve: (v) => Emit.colorRuntimeVar('tw-shadow-color', 'color', v),
+    },
+    ring: {
+        tokenFamily: 'ringWidth',
+        authoringEffect: 'ring',
+        authoringValue: {
+            kind: 'number',
+            min: 0,
+            step: 1,
+        },
+        resolve: (v) => (Emit.isEmpty(v) ? '' : v === '0' ? 'ring-0' : `ring-${String(v)}`),
+    },
+    ringColor: {
+        tokenFamily: 'color',
+        authoringEffect: 'ring',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.colorRuntimeVar('tw-ring-color', 'color', v),
+    },
+    z: {
+        tokenFamily: 'zIndex',
+        authoringEffect: 'element',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.zIndex(v),
+    },
+    inset: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('inset', v),
+    },
+    insetX: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('inset-x', v),
+    },
+    insetY: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('inset-y', v),
+    },
+    top: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('top', v),
+    },
+    right: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('right', v),
+    },
+    bottom: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('bottom', v),
+    },
+    left: {
+        tokenFamily: 'inset',
+        authoringEffect: 'element',
+        resolve: (v) => Emit.prefix('left', v),
+    },
+    align: {
+        tokenFamily: 'align',
+        authoringEffect: 'alignment',
+        resolve: (v) => Emit.align(v),
+    },
+    aspect: {
+        tokenFamily: 'aspect',
+        authoringEffect: 'element',
+        addNoneasOmit: true,
+        resolve: (v) => Emit.aspect(v),
+    },
+};
+export const CORE_DESIGN_OP_CONFIG = defineCoreOps(CORE_DESIGN_OP_CONFIG_RAW);