@roblawn/devtool-runtime 0.1.0-alpha.0

package/dist/theme-contract/ops/delegateValidation.types.d.ts

@@ -0,0 +1,46 @@
+import type { DesignOpConfigBase } from '../../design-system/ops/ops.types.js';
+import { COMPOSITE_FIELD_SPEC_BY_FAMILY, OPS_BY_TOKEN_FAMILY } from '../CompositeFieldOpByFamily.js';
+export type OpConfigRecord = Record<string, DesignOpConfigBase<string>>;
+type OpName<TConfig extends OpConfigRecord> = keyof TConfig & string;
+type TokenFamilyForOp<TConfig extends OpConfigRecord, Op extends OpName<TConfig>> = TConfig[Op]['tokenFamily'] & string;
+export type CompositeFamilyName = keyof typeof COMPOSITE_FIELD_SPEC_BY_FAMILY & string;
+type CompositeFieldKey<Family extends CompositeFamilyName> = keyof (typeof COMPOSITE_FIELD_SPEC_BY_FAMILY)[Family] & string;
+type CompositeFieldSpec<Family extends CompositeFamilyName, Field extends CompositeFieldKey<Family>> = (typeof COMPOSITE_FIELD_SPEC_BY_FAMILY)[Family][Field];
+type CompositeDefaultFieldOp<Family extends CompositeFamilyName, Field extends CompositeFieldKey<Family>> = CompositeFieldSpec<Family, Field> extends {
+    defaultOp: infer Op extends string;
+} ? Op : never;
+type CompositeTargetFamily<Family extends CompositeFamilyName, Field extends CompositeFieldKey<Family>> = CompositeFieldSpec<Family, Field> extends {
+    targetFamily: infer FamilyName extends string;
+} ? FamilyName : never;
+type KnownDelegateTargetFamily = keyof typeof OPS_BY_TOKEN_FAMILY & string;
+type OpsForTargetFamily<Family extends string> = Family extends KnownDelegateTargetFamily ? (typeof OPS_BY_TOKEN_FAMILY)[Family][number] : never;
+type OpsUsingTokenFamily<TConfig extends OpConfigRecord, Family extends string> = {
+    [Candidate in OpName<TConfig>]: TokenFamilyForOp<TConfig, Candidate> extends Family ? Candidate : never;
+}[OpName<TConfig>] & string;
+type CompositeSpecFieldError<TConfig extends OpConfigRecord, Family extends CompositeFamilyName, Field extends CompositeFieldKey<Family>> = CompositeDefaultFieldOp<Family, Field> extends OpName<TConfig> ? TokenFamilyForOp<TConfig, CompositeDefaultFieldOp<Family, Field>> extends CompositeTargetFamily<Family, Field> ? never : `${Family}.${Field}: defaultOpFamilyMismatch` : `${Family}.${Field}: defaultOpMissing`;
+type CompositeSpecError<TConfig extends OpConfigRecord> = {
+    [Family in CompositeFamilyName]: {
+        [Field in CompositeFieldKey<Family>]: CompositeSpecFieldError<TConfig, Family, Field>;
+    }[CompositeFieldKey<Family>];
+}[CompositeFamilyName];
+type CompositeSpecGuard<TConfig extends OpConfigRecord> = [
+    CompositeSpecError<TConfig>
+] extends [never] ? unknown : never;
+type DelegateMapForFamily<TConfig extends OpConfigRecord, Family extends CompositeFamilyName> = Partial<{
+    [Field in CompositeFieldKey<Family>]: CompositeDefaultFieldOp<Family, Field> extends OpName<TConfig> ? OpsUsingTokenFamily<TConfig, CompositeTargetFamily<Family, Field>> : never;
+}>;
+export type CompositeDelegateForFamily<Family extends CompositeFamilyName> = Partial<{
+    [Field in CompositeFieldKey<Family>]: OpsForTargetFamily<CompositeTargetFamily<Family, Field>>;
+}>;
+type StrictCompositeDelegateForFamily<Family extends CompositeFamilyName, Delegate extends Record<string, string>> = CompositeDelegateForFamily<Family> & Delegate & Record<Exclude<keyof Delegate, keyof CompositeDelegateForFamily<Family>>, never>;
+export declare function defineDelegate<Family extends CompositeFamilyName, const Delegate extends Record<string, string>>(_family: Family, delegate: StrictCompositeDelegateForFamily<Family, Delegate>): CompositeDelegateForFamily<Family>;
+export type DelegateMapForOp<TConfig extends OpConfigRecord, Op extends OpName<TConfig>> = TokenFamilyForOp<TConfig, Op> extends infer Family ? Family extends CompositeFamilyName ? DelegateMapForFamily<TConfig, Family> : never : never;
+type StrictDelegateForOp<TConfig extends OpConfigRecord, Op extends OpName<TConfig>> = TConfig[Op] extends {
+    delegate: infer Delegate;
+} ? Delegate extends Record<string, string> ? DelegateMapForOp<TConfig, Op> & Record<Exclude<keyof Delegate, keyof DelegateMapForOp<TConfig, Op>>, never> : DelegateMapForOp<TConfig, Op> : DelegateMapForOp<TConfig, Op>;
+export type ValidateOpConfig<TConfig extends OpConfigRecord> = {
+    [Op in OpName<TConfig>]: Omit<TConfig[Op], 'delegate'> & {
+        delegate?: StrictDelegateForOp<TConfig, Op>;
+    };
+} & CompositeSpecGuard<TConfig>;
+export {};

package/dist/theme-contract/ops/delegateValidation.types.js

@@ -0,0 +1,4 @@
+import { COMPOSITE_FIELD_SPEC_BY_FAMILY, OPS_BY_TOKEN_FAMILY } from '../CompositeFieldOpByFamily.js';
+export function defineDelegate(_family, delegate) {
+    return delegate;
+}

package/dist/theme-contract/ops/emitters.d.ts

@@ -0,0 +1,24 @@
+export declare class Emit {
+    static isEmpty(value: unknown): boolean;
+    static prefix(prefix: string, value: unknown): string;
+    static rounded(prefix: string, value: unknown): string;
+    static composite(value: unknown): string;
+    static containerSize(prefix: string, value: unknown): string;
+    static containerSizeAlias(prefix: string, value: unknown): string;
+    static contentWidth(value: unknown): string;
+    static align(value: unknown): string;
+    static shadow(value: unknown): string;
+    static shadowTokenVar(cssVarName: string, tokenVarPrefix: string, value: unknown): string;
+    static shadowOpacityVar(cssVarName: string, value: unknown): string;
+    static colorRuntimeVar(cssVarName: string, tokenPrefix: string, value: unknown): string;
+    static shadowCompose(value: unknown): string;
+    static border(value: string): string;
+    static borderComposite(value: unknown): string;
+    static borderCompositeSide(side: 't' | 'r' | 'b' | 'l', value: unknown): string;
+    static borderCompositeAxis(axis: 'x' | 'y', value: unknown): string;
+    static divideBorder(value: string): string;
+    static divideComposite(value: unknown): string;
+    static zIndex(value: unknown): string;
+    static aspect(value: unknown): string;
+    static aspectAlias(value: unknown): string;
+}

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

@@ -0,0 +1,151 @@
+const CONTAINER_PASSTHROUGH_SPECIALS = new Set(['full', 'screen', 'fit', 'min', 'max']);
+const CONTAINER_ALIAS_PASSTHROUGH = new Set(['full', 'screen', 'fit', 'min', 'max', 'none']);
+const ASPECT_ALIAS_PASSTHROUGH = new Set(['auto', 'square', 'video', 'none']);
+export class Emit {
+    static isEmpty(value) {
+        return value === undefined || value === null || value === '' || value === false;
+    }
+    static prefix(prefix, value) {
+        return Emit.isEmpty(value) ? '' : `${prefix}-${String(value)}`;
+    }
+    static rounded(prefix, value) {
+        if (Emit.isEmpty(value))
+            return '';
+        return value === 'none' ? `${prefix}-none` : `${prefix}-${String(value)}`;
+    }
+    static composite(value) {
+        return Emit.isEmpty(value) ? '' : String(value);
+    }
+    static containerSize(prefix, value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        if (CONTAINER_PASSTHROUGH_SPECIALS.has(key))
+            return `${prefix}-${key}`;
+        return `${prefix}-(--container-${key})`;
+    }
+    static containerSizeAlias(prefix, value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        if (CONTAINER_ALIAS_PASSTHROUGH.has(key))
+            return '';
+        return `${prefix}-${key}`;
+    }
+    static contentWidth(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        if (key === 'fit' || key === 'min' || key === 'max' || key === 'full')
+            return `w-${key}`;
+        if (key === 'screen')
+            return 'w-full max-w-screen';
+        return `w-full max-w-(--container-${key})`;
+    }
+    static align(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        if (key === 'left' || key === 'start')
+            return '';
+        if (key === 'center')
+            return 'mx-auto';
+        if (key === 'right' || key === 'end')
+            return 'ml-auto';
+        return '';
+    }
+    static shadow(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        return `shadow-style-${key}`;
+    }
+    static shadowTokenVar(cssVarName, tokenVarPrefix, value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const numericValue = Number(String(value));
+        if (Number.isFinite(numericValue)) {
+            return `[--${cssVarName}:${numericValue}px]`;
+        }
+        return `[--${cssVarName}:var(--${tokenVarPrefix}-${String(value)})]`;
+    }
+    static shadowOpacityVar(cssVarName, value) {
+        if (Emit.isEmpty(value))
+            return '';
+        return `[--${cssVarName}:calc(${String(value)}/100)]`;
+    }
+    static colorRuntimeVar(cssVarName, tokenPrefix, value) {
+        if (Emit.isEmpty(value) || value === 'none')
+            return '';
+        return `[--${cssVarName}:var(--${tokenPrefix}-${String(value)})]`;
+    }
+    static shadowCompose(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        const layer1 = 'var(--shadow-x-1)_var(--shadow-y-1)_var(--shadow-blur-1)_var(--shadow-spread-1)_rgb(from_var(--tw-shadow-color)_r_g_b/var(--shadow-opacity-1))';
+        const layer2 = 'var(--shadow-x-2)_var(--shadow-y-2)_var(--shadow-blur-2)_var(--shadow-spread-2)_rgb(from_var(--tw-shadow-color)_r_g_b/var(--shadow-opacity-2))';
+        if (key === 'none')
+            return 'shadow-none';
+        if (key === 'single')
+            return `[box-shadow:${layer1}]`;
+        if (key === 'double')
+            return `[box-shadow:${layer1},${layer2}]`;
+        return '';
+    }
+    static border(value) {
+        const numericValue = Number(String(value));
+        if (!Number.isFinite(numericValue)) {
+            return Emit.isEmpty(value) ? 'border-1' : `border-(length:--border-${String(value)})`;
+        }
+        if (Number.isInteger(numericValue)) {
+            return `border-${numericValue}`;
+        }
+        return `border-[${numericValue}px]`;
+    }
+    static borderComposite(value) {
+        return Emit.isEmpty(value) ? '' : `border-${String(value)}`;
+    }
+    static borderCompositeSide(side, value) {
+        return Emit.isEmpty(value) ? '' : `border-${side}-${String(value)}`;
+    }
+    static borderCompositeAxis(axis, value) {
+        return Emit.isEmpty(value) ? '' : `border-${axis}-${String(value)}`;
+    }
+    static divideBorder(value) {
+        const numericValue = Number(String(value));
+        if (!Number.isFinite(numericValue)) {
+            return Emit.isEmpty(value) ? '' : `divide-x-(--border-${String(value)})`;
+        }
+        if (Number.isInteger(numericValue)) {
+            return `divide-x-${numericValue}`;
+        }
+        return `divide-x-[${numericValue}px]`;
+    }
+    static divideComposite(value) {
+        return Emit.isEmpty(value) ? '' : `divide-border-${String(value)}`;
+    }
+    static zIndex(value) {
+        return Emit.isEmpty(value) ? 'z-auto' : `z-(--z-${String(value)})`;
+    }
+    static aspect(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        if (key === 'auto')
+            return 'aspect-auto';
+        if (key === 'square')
+            return 'aspect-square';
+        if (key === 'video')
+            return 'aspect-video';
+        return `[aspect-ratio:var(--aspect-${key})]`;
+    }
+    static aspectAlias(value) {
+        if (Emit.isEmpty(value))
+            return '';
+        const key = String(value);
+        if (ASPECT_ALIAS_PASSTHROUGH.has(key))
+            return '';
+        return `aspect-${key}`;
+    }
+}