@roblawn/devtool-runtime 0.1.0-alpha.0

package/dist/cms/CMSSchemaTypes.d.ts

@@ -0,0 +1,141 @@
+export type CMSFieldPrimitiveType = 'text' | 'textarea' | 'richtext' | 'number' | 'checkbox' | 'select' | 'multiselect' | 'group' | 'array' | 'text-array' | 'number-array' | 'image' | 'icon' | 'link';
+export type CMSSimpleValidation = {
+    kind: 'required';
+    message?: string;
+} | {
+    kind: 'minLength';
+    value: number;
+    message?: string;
+} | {
+    kind: 'maxLength';
+    value: number;
+    message?: string;
+} | {
+    kind: 'regex';
+    pattern: string;
+    flags?: string;
+    message?: string;
+} | {
+    kind: 'min';
+    value: number;
+    message?: string;
+} | {
+    kind: 'max';
+    value: number;
+    message?: string;
+};
+export interface BaseCMSField {
+    type: string;
+    label: string;
+    description?: string;
+    required?: boolean;
+    setDefaultValue?: boolean;
+    defaultValue?: unknown;
+    hardCoded?: boolean;
+    hidden?: boolean;
+    readOnly?: boolean;
+    group?: string;
+    preview?: CMSFieldPreview;
+    omit?: boolean;
+}
+export interface CMSFieldPreview {
+    isTitle?: boolean;
+    isSubtitle?: boolean;
+    isMedia?: boolean;
+}
+export interface TextCMSField extends BaseCMSField {
+    type: 'text';
+    input?: 'text' | 'textarea' | 'email' | 'code';
+    validations?: CMSSimpleValidation[];
+    defaultValue?: string;
+}
+export interface NumberCMSField extends BaseCMSField {
+    type: 'number';
+    validations?: CMSSimpleValidation[];
+    defaultValue?: number;
+}
+export interface CheckboxCMSField extends BaseCMSField {
+    type: 'checkbox';
+    defaultValue?: boolean;
+}
+export interface SelectCMSField extends BaseCMSField {
+    type: 'select';
+    options: {
+        label: string;
+        value: string;
+    }[];
+    display?: 'select' | 'radio';
+    defaultValue?: string;
+}
+export interface MultiSelectCMSField extends BaseCMSField {
+    type: 'multiselect';
+    options: {
+        label: string;
+        value: string;
+    }[];
+    defaultValue?: string[];
+}
+export interface GroupCMSField extends BaseCMSField {
+    type: 'group';
+    fields: Record<string, CMSSchemaField>;
+    defaultValue?: Record<string, unknown>;
+}
+export type CMSPrimitiveArrayItemType = 'image' | 'link' | 'richtext';
+export interface ArrayCMSField extends BaseCMSField {
+    type: 'array';
+    fields: Record<string, CMSSchemaField>;
+    itemType?: CMSPrimitiveArrayItemType;
+    minRows?: number;
+    maxRows?: number;
+    defaultValue?: Record<string, unknown>[];
+}
+export interface TextArrayCMSField extends BaseCMSField {
+    type: 'text-array';
+    minRows?: number;
+    maxRows?: number;
+    defaultValue?: string[];
+}
+export interface NumberArrayCMSField extends BaseCMSField {
+    type: 'number-array';
+    minRows?: number;
+    maxRows?: number;
+    defaultValue?: number[];
+}
+export interface ImageCMSField extends BaseCMSField {
+    type: 'image';
+    allowExternalUrl?: boolean;
+    defaultValue?: {
+        asset?: {
+            _ref: string;
+        };
+        url?: string;
+        alt?: string;
+    } | string;
+}
+export interface RichTextField extends BaseCMSField {
+    type: 'richtext';
+    defaultValue?: Record<string, unknown>[];
+}
+export interface IconCMSField extends BaseCMSField {
+    type: 'icon';
+    defaultValue?: string;
+}
+export interface LinkCMSField extends BaseCMSField {
+    type: 'link';
+    defaultValue?: {
+        href: string;
+        label?: string;
+    };
+}
+export type CMSSchemaField = TextCMSField | NumberCMSField | CheckboxCMSField | SelectCMSField | MultiSelectCMSField | GroupCMSField | ArrayCMSField | TextArrayCMSField | NumberArrayCMSField | ImageCMSField | IconCMSField | LinkCMSField | RichTextField;
+export interface CMSSchemaMeta {
+    title: string;
+    subtitle?: string;
+}
+export interface CMSSchema {
+    name: string;
+    meta: CMSSchemaMeta;
+    fields: Record<string, CMSSchemaField>;
+    omit?: boolean;
+    __deprecated?: Record<string, CMSSchemaField>;
+}

package/dist/cms/CMSSchemaTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/cms/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CMSSchema.js';
+export type * from './CMSSchemaTypes.js';
+export type * from './CMSPresenterSchemaTypes.js';

package/dist/cms/index.js

@@ -0,0 +1 @@
+export * from './CMSSchema.js';

package/dist/design-system/DesignSystemSnapshotFactory.d.ts

@@ -0,0 +1,34 @@
+import type { CompositeTokenLeafValue, TokenFamilySchema } from './tokens/TokenSchemas.types.js';
+import type { CoreTokenFamilies } from './tokens/coreTokenFamilies.types.js';
+import type { DesignOpConfigBase } from './ops/ops.types.js';
+export type TokenValue = string | Record<string, CompositeTokenLeafValue>;
+export interface TokenRegistryRuntime<TTokens extends Record<string, Record<string, TokenValue>>> {
+    readonly TOKENS: TTokens;
+    readonly TOKEN_FAMILIES: {
+        [family: string]: {
+            description: string;
+            semanticType: string;
+        };
+    };
+}
+export interface RuntimeDesignSystemSnapshot<TFamily extends string = string, TOp extends string = string> {
+    readonly tokenFamilies: Record<TFamily, readonly string[]>;
+    readonly ops: readonly TOp[];
+    getTokensForFamily(family: TFamily): readonly string[];
+    getTokensForOp(op: TOp): readonly string[];
+    resolve(op: TOp, value: string | number): string;
+}
+type FamilyName<TRegistry extends Record<string, Record<string, TokenValue>>, TCore extends CoreTokenFamilies> = (keyof TRegistry & string) | (keyof TCore & string);
+export interface DesignSystemWiring<TRegistryTokens extends Record<string, Record<string, TokenValue>>, TCore extends CoreTokenFamilies, TOpConfig extends Record<string, DesignOpConfigBase<string>>> {
+    readonly registry: TokenRegistryRuntime<TRegistryTokens>;
+    readonly coreFamilies: TCore;
+    readonly tokenSchemas: readonly TokenFamilySchema[];
+    readonly opConfig: TOpConfig;
+}
+export interface FullDesignSystemSnapshot<TRegistryTokens extends Record<string, Record<string, TokenValue>>, TCore extends CoreTokenFamilies, TOpConfig extends Record<string, DesignOpConfigBase<string>>> extends RuntimeDesignSystemSnapshot<FamilyName<TRegistryTokens, TCore>, keyof TOpConfig & string> {
+    readonly tokenSchemasMeta: TokenRegistryRuntime<TRegistryTokens>['TOKEN_FAMILIES'];
+    readonly opConfig: TOpConfig;
+    readonly tokenSchemasRaw: readonly TokenFamilySchema[];
+}
+export declare function createDesignSystemSnapshot<TRegistryTokens extends Record<string, Record<string, TokenValue>>, TCore extends CoreTokenFamilies, TOpConfig extends Record<string, DesignOpConfigBase<string>>>(wiring: DesignSystemWiring<TRegistryTokens, TCore, TOpConfig>): FullDesignSystemSnapshot<TRegistryTokens, TCore, TOpConfig>;
+export {};

package/dist/design-system/DesignSystemSnapshotFactory.js

@@ -0,0 +1,38 @@
+import { resolveOp } from './resolvers/ds.resolvers.js';
+function buildTokenFamiliesMap(registry, coreFamilies) {
+    const result = {};
+    for (const family of Object.keys(registry.TOKENS)) {
+        const record = registry.TOKENS[family];
+        result[family] = Object.keys(record);
+    }
+    for (const family of Object.keys(coreFamilies)) {
+        const values = coreFamilies[family];
+        result[family] = values.map((v) => String(v));
+    }
+    return result;
+}
+export function createDesignSystemSnapshot(wiring) {
+    const { registry, coreFamilies, tokenSchemas, opConfig } = wiring;
+    const tokenFamiliesMap = buildTokenFamiliesMap(registry, coreFamilies);
+    const ops = Object.keys(opConfig);
+    const snapshot = {
+        tokenFamilies: tokenFamiliesMap,
+        tokenSchemasMeta: registry.TOKEN_FAMILIES,
+        tokenSchemasRaw: tokenSchemas,
+        ops,
+        opConfig,
+        getTokensForFamily(family) {
+            return tokenFamiliesMap[family] ?? [];
+        },
+        getTokensForOp(op) {
+            const config = opConfig[op];
+            if (!config)
+                return [];
+            return this.getTokensForFamily(config.tokenFamily);
+        },
+        resolve(op, value) {
+            return resolveOp(opConfig, op, value);
+        },
+    };
+    return snapshot;
+}

package/dist/design-system/ProjectDesignSystemFactory.d.ts

@@ -0,0 +1,39 @@
+import { type FullDesignSystemSnapshot } from './DesignSystemSnapshotFactory.js';
+import type { CompositeTokenLeafValue, TokenFamilySchema } from './tokens/TokenSchemas.types.js';
+import type { DesignOpConfigBase } from './ops/ops.types.js';
+import type { CoreTokenFamilies } from './tokens/coreTokenFamilies.types.js';
+export type TokenValue = string | Record<string, CompositeTokenLeafValue>;
+export type ProjectTokenRegistryTokens = Record<string, Record<string, TokenValue>>;
+export interface ProjectTokenRegistryConfig<TTokens extends ProjectTokenRegistryTokens, TFamilies extends Record<string, {
+    description: string;
+    semanticType: string;
+}>, TCore extends CoreTokenFamilies, TOpConfig extends Record<string, DesignOpConfigBase<string>>> {
+    readonly TOKENS: TTokens;
+    readonly TOKEN_FAMILIES: TFamilies;
+    readonly TOKEN_SCHEMAS: readonly TokenFamilySchema[];
+    readonly CORE_TOKEN_FAMILIES: TCore;
+    readonly OP_CONFIG: TOpConfig;
+}
+export type DesignOp<TOpConfig extends Record<string, DesignOpConfigBase<string>>> = keyof TOpConfig & string;
+export interface BaseDesignSystemApi<TTokens extends ProjectTokenRegistryTokens, TFamilies extends Record<string, {
+    description: string;
+    semanticType: string;
+}>, TCore extends CoreTokenFamilies, TOpConfig extends Record<string, DesignOpConfigBase<string>>> {
+    readonly ops: readonly DesignOp<TOpConfig>[];
+    readonly opConfig: TOpConfig;
+    readonly tokenSchemas: readonly TokenFamilySchema[];
+    readonly coreFamilies: TCore;
+    readonly registryTokens: TTokens;
+    readonly registryFamilies: TFamilies;
+    resolve(op: DesignOp<TOpConfig>, value: string | number): string;
+    getTokensForFamily(family: string): readonly string[];
+    getTokensForOp(op: DesignOp<TOpConfig>): readonly string[];
+}
+export declare function createProjectDesignSystem<TTokens extends ProjectTokenRegistryTokens, TFamilies extends Record<string, {
+    description: string;
+    semanticType: string;
+}>, TCore extends CoreTokenFamilies, TOpConfig extends Record<string, DesignOpConfigBase<string>>>(config: ProjectTokenRegistryConfig<TTokens, TFamilies, TCore, TOpConfig>): {
+    readonly DESIGN_SYSTEM_SNAPSHOT: FullDesignSystemSnapshot<TTokens, TCore, TOpConfig>;
+    readonly DesignSystem: BaseDesignSystemApi<TTokens, TFamilies, TCore, TOpConfig>;
+};
+export type { FullDesignSystemSnapshot };

package/dist/design-system/ProjectDesignSystemFactory.js

@@ -0,0 +1,32 @@
+import { createDesignSystemSnapshot } from './DesignSystemSnapshotFactory.js';
+export function createProjectDesignSystem(config) {
+    const wiring = {
+        registry: {
+            TOKENS: config.TOKENS,
+            TOKEN_FAMILIES: config.TOKEN_FAMILIES,
+        },
+        coreFamilies: config.CORE_TOKEN_FAMILIES,
+        tokenSchemas: config.TOKEN_SCHEMAS,
+        opConfig: config.OP_CONFIG,
+    };
+    const snapshot = createDesignSystemSnapshot(wiring);
+    const ops = Object.keys(config.OP_CONFIG);
+    const DesignSystem = {
+        ops,
+        opConfig: config.OP_CONFIG,
+        tokenSchemas: config.TOKEN_SCHEMAS,
+        coreFamilies: config.CORE_TOKEN_FAMILIES,
+        registryTokens: config.TOKENS,
+        registryFamilies: config.TOKEN_FAMILIES,
+        getTokensForFamily(family) {
+            return snapshot.getTokensForFamily(family);
+        },
+        getTokensForOp(op) {
+            return snapshot.getTokensForOp(op);
+        },
+        resolve(op, value) {
+            return snapshot.resolve(op, value);
+        },
+    };
+    return { DESIGN_SYSTEM_SNAPSHOT: snapshot, DesignSystem };
+}

package/dist/design-system/index.d.ts

@@ -0,0 +1,8 @@
+export * from './DesignSystemSnapshotFactory.js';
+export { createProjectDesignSystem, } from './ProjectDesignSystemFactory.js';
+export type { BaseDesignSystemApi, DesignOp, FullDesignSystemSnapshot, ProjectTokenRegistryConfig, ProjectTokenRegistryTokens, } from './ProjectDesignSystemFactory.js';
+export * from './ops/ops.types.js';
+export * from './tokens/TokenSchemas.types.js';
+export * from './tokens/coreTokenFamilies.types.js';
+export * from './resolvers/ds.resolvers.js';
+export * from './resolvers/ds.responsive.js';

package/dist/design-system/index.js

@@ -0,0 +1,7 @@
+export * from './DesignSystemSnapshotFactory.js';
+export { createProjectDesignSystem, } from './ProjectDesignSystemFactory.js';
+export * from './ops/ops.types.js';
+export * from './tokens/TokenSchemas.types.js';
+export * from './tokens/coreTokenFamilies.types.js';
+export * from './resolvers/ds.resolvers.js';
+export * from './resolvers/ds.responsive.js';

package/dist/design-system/ops/ops.types.d.ts

@@ -0,0 +1,22 @@
+import type { CoreTokenFamilyName } from '../tokens/coreTokenFamilies.types.js';
+export type AuthoringEffectKind = 'element' | 'text' | 'text-style' | 'title-style' | 'text-alignment' | 'divide' | 'divide-x' | 'divide-y' | 'margin' | 'margin-top' | 'margin-right' | 'margin-bottom' | 'margin-left' | 'margin-x' | 'margin-y' | 'padding' | 'padding-top' | 'padding-right' | 'padding-bottom' | 'padding-left' | 'padding-x' | 'padding-y' | 'gap' | 'gap-x' | 'gap-y' | 'background' | 'color' | 'border' | 'border-top' | 'border-right' | 'border-bottom' | 'border-left' | 'ring' | 'shadow' | 'radius' | 'radius-top' | 'radius-right' | 'radius-bottom' | 'radius-left' | 'width' | 'height' | 'min-width' | 'min-height' | 'max-width' | 'max-height' | 'alignment';
+export type TokenFamilyName = CoreTokenFamilyName | string;
+export type NoneBehavior = 'empty' | 'passThrough';
+export interface NumberAuthoringValueSpec {
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+}
+export type DesignOpAuthoringValue = NumberAuthoringValueSpec;
+export interface DesignOpConfigBase<TFamily extends string = TokenFamilyName, TDelegateField extends string = string, TDelegateOp extends string = string> {
+    tokenFamily: TFamily;
+    authoringEffect?: AuthoringEffectKind;
+    authoringValue?: DesignOpAuthoringValue;
+    responsive?: boolean;
+    addNoneasOmit?: boolean;
+    resolve?: (value: string) => string;
+    useAlias?: (value: string) => string;
+    private?: boolean;
+    delegate?: Partial<Record<TDelegateField, TDelegateOp>>;
+}

package/dist/design-system/ops/ops.types.js

@@ -0,0 +1 @@
+export {};

package/dist/design-system/resolvers/ds.resolvers.d.ts

@@ -0,0 +1,3 @@
+import type { DesignOpConfigBase } from '../ops/ops.types.js';
+export declare function normalizeNone<Op extends string>(opConfig: Record<Op, DesignOpConfigBase<string>>, op: Op, value: string | number): string;
+export declare function resolveOp<Op extends string>(opConfig: Record<Op, DesignOpConfigBase<string>>, op: Op, value: string | number): string;

package/dist/design-system/resolvers/ds.resolvers.js

@@ -0,0 +1,24 @@
+export function normalizeNone(opConfig, op, value) {
+    if (value !== 'none')
+        return String(value);
+    const cfg = opConfig[op];
+    return cfg?.addNoneasOmit === true ? '' : value;
+}
+export function resolveOp(opConfig, op, value) {
+    const normalized = normalizeNone(opConfig, op, value);
+    if (normalized.length === 0)
+        return '';
+    const cfg = opConfig[op];
+    if (!cfg || typeof cfg.resolve !== 'function')
+        return '';
+    try {
+        return cfg.resolve(normalized) ?? '';
+    }
+    catch (error) {
+        if (error instanceof Error)
+            console.log(error.message);
+        else
+            console.log('An unknown error occurred');
+        return '';
+    }
+}

package/dist/design-system/resolvers/ds.responsive.d.ts

@@ -0,0 +1,12 @@
+export type BreakpointOrder = readonly string[];
+export type ResponsiveOverrides<TokenKey extends string> = Readonly<Record<string, TokenKey | undefined>>;
+export type TokenToClassResolver<TOp extends string, TokenKey extends string> = (op: TOp, token: TokenKey) => string;
+export declare function prefixClasses(prefix: string, classString: string): string;
+export declare function cx(...parts: Array<string | false | null | undefined>): string;
+export declare function buildResponsiveClassString<TOp extends string, TokenKey extends string>(args: {
+    readonly op: TOp;
+    readonly baseToken: TokenKey;
+    readonly breakpointOrder: BreakpointOrder;
+    readonly overrides: ResponsiveOverrides<TokenKey>;
+    readonly resolveTokenToClasses: TokenToClassResolver<TOp, TokenKey>;
+}): string;

package/dist/design-system/resolvers/ds.responsive.js

@@ -0,0 +1,28 @@
+export function prefixClasses(prefix, classString) {
+    const trimmed = classString.trim();
+    if (trimmed.length === 0)
+        return '';
+    const parts = trimmed.split(/\s+/).filter((p) => p.length > 0);
+    return parts.map((p) => `${prefix}:${p}`).join(' ');
+}
+export function cx(...parts) {
+    return parts.filter((p) => typeof p === 'string' && p.length > 0).join(' ');
+}
+export function buildResponsiveClassString(args) {
+    const base = args.resolveTokenToClasses(args.op, args.baseToken) ?? '';
+    const overrideKeys = Object.keys(args.overrides);
+    if (overrideKeys.length === 0) {
+        return base;
+    }
+    const responsiveParts = [];
+    for (const bp of args.breakpointOrder) {
+        const tokenAtBp = args.overrides[bp];
+        if (!tokenAtBp)
+            continue;
+        const resolved = args.resolveTokenToClasses(args.op, tokenAtBp) ?? '';
+        if (resolved.trim().length === 0)
+            continue;
+        responsiveParts.push(prefixClasses(bp, resolved));
+    }
+    return cx(base, ...responsiveParts);
+}

package/dist/design-system/tokens/TokenSchemas.types.d.ts

@@ -0,0 +1,48 @@
+export type TokenSemanticType = 'css-color' | 'rem' | 'number' | 'string' | 'aspect-ratio' | 'px' | 'em' | 'composite';
+export type TokenOrderMode = {
+    type: 'custom';
+} | {
+    type: 'alpha';
+    direction?: 'asc' | 'desc';
+} | {
+    type: 'numeric';
+    direction?: 'asc' | 'desc';
+};
+export type CompositeTokenOrderMode = {
+    type: 'custom';
+} | {
+    type: 'alpha';
+    direction?: 'asc' | 'desc';
+};
+export type CompositeTokenField<Key extends string = string, Op extends string = string> = {
+    readonly key: Key;
+    readonly op: Op;
+    readonly description?: string;
+};
+export interface TokenFamilySchemaBase<Name extends string = string, Order extends TokenOrderMode = TokenOrderMode> {
+    readonly name: Name;
+    readonly description: string;
+    readonly responsive?: boolean;
+    readonly editorVisible?: boolean;
+    readonly tokenDescriptions?: boolean;
+    readonly order: Order;
+    readonly semanticType: TokenSemanticType;
+}
+export interface PrimitiveTokenFamilySchema<Name extends string = string> extends TokenFamilySchemaBase<Name, TokenOrderMode> {
+    readonly semanticType: Exclude<TokenSemanticType, 'composite'>;
+    readonly initialTokens?: Record<string, string>;
+    readonly toCssVarName: (tokenKey: string) => string | null;
+    readonly toCssVarAliases?: (tokenKey: string, cssVarName: string) => readonly string[];
+    readonly toCssVarValue: (tokenKey: string, tokenValue: string) => string;
+}
+export type CompositeFieldKeys<Fields extends readonly CompositeTokenField[]> = Fields[number]['key'] & string;
+export type CompositeTokenLeafValue = string | number;
+export type CompositeTokenValue<Fields extends readonly CompositeTokenField[]> = Partial<Record<CompositeFieldKeys<Fields>, CompositeTokenLeafValue>>;
+export interface CompositeTokenFamilySchema<Name extends string = string, Fields extends readonly CompositeTokenField[] = readonly CompositeTokenField[]> extends TokenFamilySchemaBase<Name, CompositeTokenOrderMode> {
+    readonly semanticType: 'composite';
+    readonly fields: Fields;
+    readonly defaults?: Partial<Record<CompositeFieldKeys<Fields>, CompositeTokenLeafValue>>;
+    readonly initialTokens?: Record<string, CompositeTokenValue<Fields>>;
+}
+export type TokenFamilySchema<Name extends string = string> = PrimitiveTokenFamilySchema<Name> | CompositeTokenFamilySchema<Name, readonly CompositeTokenField[]>;
+export declare function defineTokenFamilySchema<const T extends TokenFamilySchema>(schema: T): T;

package/dist/design-system/tokens/TokenSchemas.types.js

@@ -0,0 +1,3 @@
+export function defineTokenFamilySchema(schema) {
+    return schema;
+}

package/dist/design-system/tokens/coreTokenFamilies.types.d.ts

@@ -0,0 +1,2 @@
+export type CoreTokenFamilies = Record<string, readonly (string | number)[]>;
+export type CoreTokenFamilyName = keyof CoreTokenFamilies & string;

package/dist/design-system/tokens/coreTokenFamilies.types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './design-system/index.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './design-system/index.js';

package/dist/layout/index.d.ts

@@ -0,0 +1 @@
+export * from './layoutRuntime.js';

package/dist/layout/index.js

@@ -0,0 +1 @@
+export * from './layoutRuntime.js';

package/dist/layout/layoutRuntime.d.ts

@@ -0,0 +1,12 @@
+import type { LayoutBindingValue, LayoutProps, LayoutVariantRegistry, RootLayoutBinding } from '../types/layout.types.js';
+export interface LayoutRuntimeContext {
+    layout: LayoutProps;
+    variants: LayoutVariantRegistry;
+}
+export type LayoutSource = LayoutProps | RootLayoutBinding | null | undefined;
+export declare function resolveRootLayoutProps(binding: RootLayoutBinding | null | undefined, registry: LayoutVariantRegistry): LayoutProps;
+export declare function normaliseLayoutSource(source: LayoutSource, registry: LayoutVariantRegistry): LayoutProps;
+export declare function makeLayoutRuntimeContext(layout: LayoutSource, variants: LayoutVariantRegistry | null | undefined): LayoutRuntimeContext;
+export declare function resolveLayoutBinding(binding: LayoutBindingValue, registry: LayoutVariantRegistry): Record<string, unknown> | null;
+export declare function getLayoutField(ctx: LayoutRuntimeContext, field: string): unknown;
+export declare function getWrapperProps<TProps extends Record<string, unknown>>(ctx: LayoutRuntimeContext, field: string, wrapperName: string): TProps | null;

package/dist/layout/layoutRuntime.js

@@ -0,0 +1,88 @@
+function isRootLayoutBinding(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    if (typeof candidate.kind !== 'string' || typeof candidate.name !== 'string') {
+        return false;
+    }
+    const hasProps = candidate.props !== undefined;
+    const hasVariant = typeof candidate.variant === 'string';
+    if (!hasProps && !hasVariant) {
+        return false;
+    }
+    return true;
+}
+export function resolveRootLayoutProps(binding, registry) {
+    if (!binding) {
+        return {};
+    }
+    if ('props' in binding && binding.props && typeof binding.props === 'object') {
+        return binding.props;
+    }
+    const hasVariant = 'variant' in binding && typeof binding.variant === 'string';
+    if (!hasVariant) {
+        return {};
+    }
+    const match = registry.find((record) => record.key.kind === binding.kind && record.key.name === binding.name && record.key.variant === binding.variant);
+    if (!match) {
+        return {};
+    }
+    return match.props;
+}
+export function normaliseLayoutSource(source, registry) {
+    if (!source) {
+        return {};
+    }
+    if (isRootLayoutBinding(source)) {
+        return resolveRootLayoutProps(source, registry);
+    }
+    return source;
+}
+export function makeLayoutRuntimeContext(layout, variants) {
+    const safeVariants = Array.isArray(variants) ? variants : [];
+    const safeLayout = normaliseLayoutSource(layout, safeVariants);
+    return {
+        layout: safeLayout,
+        variants: safeVariants,
+    };
+}
+export function resolveLayoutBinding(binding, registry) {
+    if ('props' in binding && binding.props) {
+        return binding.props;
+    }
+    const { kind, name } = binding;
+    const variant = binding.variant;
+    if (typeof variant !== 'string' || variant.length === 0) {
+        return null;
+    }
+    const match = registry.find((record) => record.key.kind === kind && record.key.name === name && record.key.variant === variant);
+    return match?.props ?? null;
+}
+export function getLayoutField(ctx, field) {
+    const raw = ctx.layout[field];
+    if (typeof raw !== 'object' || raw === null) {
+        return raw;
+    }
+    const maybeBinding = raw;
+    if (typeof maybeBinding.kind !== 'string' || typeof maybeBinding.name !== 'string') {
+        return raw;
+    }
+    const resolved = resolveLayoutBinding(maybeBinding, ctx.variants);
+    return resolved ?? raw;
+}
+export function getWrapperProps(ctx, field, wrapperName) {
+    const raw = ctx.layout[field];
+    if (typeof raw !== 'object' || raw === null) {
+        return null;
+    }
+    const maybeBinding = raw;
+    if (maybeBinding.kind !== 'wrapper' || maybeBinding.name !== wrapperName) {
+        return null;
+    }
+    const resolved = resolveLayoutBinding(maybeBinding, ctx.variants);
+    if (!resolved) {
+        return null;
+    }
+    return resolved;
+}

package/dist/schema/LayoutBindingEditorPolicyMetadata.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+export type BindingEditorPolicyVariants = 'primary' | 'optional' | 'none';
+export type BindingEditorPolicy = {
+    variants: BindingEditorPolicyVariants;
+};
+export declare function annotateBindingEditorPolicy<TSchema extends z.ZodTypeAny>(schema: TSchema, policy: BindingEditorPolicy): TSchema;
+export declare function getBindingEditorPolicy(schema: unknown): BindingEditorPolicy | null;

package/dist/schema/LayoutBindingEditorPolicyMetadata.js

@@ -0,0 +1,19 @@
+const LAYOUT_BINDING_EDITOR_POLICY_META_KEY = Symbol.for('devtool-runtime:layout-binding-editor-policy');
+export function annotateBindingEditorPolicy(schema, policy) {
+    const maybeDef = schema._def;
+    if (maybeDef) {
+        maybeDef[LAYOUT_BINDING_EDITOR_POLICY_META_KEY] = policy;
+    }
+    return schema;
+}
+export function getBindingEditorPolicy(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const policy = def[LAYOUT_BINDING_EDITOR_POLICY_META_KEY];
+    if (!policy || typeof policy !== 'object')
+        return null;
+    return policy;
+}

package/dist/schema/LayoutBindingEditorSectionMetadata.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+export type BindingEditorSectionKey = 'general' | 'margin' | 'backgroundBorder' | 'widthAlignment' | 'spacing' | 'typography' | 'images' | 'buttons' | 'grid' | 'effects' | 'position' | 'dividers';
+export type BindingEditorSection = {
+    section: BindingEditorSectionKey;
+};
+export declare function annotateBindingEditorSection<TSchema extends z.ZodTypeAny>(schema: TSchema, section: BindingEditorSection): TSchema;
+export declare function getBindingEditorSection(schema: unknown): BindingEditorSection | null;

package/dist/schema/LayoutBindingEditorSectionMetadata.js

@@ -0,0 +1,19 @@
+const LAYOUT_BINDING_EDITOR_SECTION_META_KEY = Symbol.for('devtool-runtime:layout-binding-editor-section');
+export function annotateBindingEditorSection(schema, section) {
+    const maybeDef = schema._def;
+    if (maybeDef) {
+        maybeDef[LAYOUT_BINDING_EDITOR_SECTION_META_KEY] = section;
+    }
+    return schema;
+}
+export function getBindingEditorSection(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const section = def[LAYOUT_BINDING_EDITOR_SECTION_META_KEY];
+    if (!section || typeof section !== 'object')
+        return null;
+    return section;
+}