css-calipers 0.9.3 → 0.9.4

package/dist/esm/containerQueries/containerQueries.js

@@ -0,0 +1,109 @@
+import { emitAspectRatioFeatures, emitBlockSizeFeatures, emitCustomFeatures, emitInlineSizeFeatures, emitStyleFeatures, } from "./modules";
+import { runContainerQueryLint } from "./linting";
+import { lintHeightExactRedundancy, lintWidthExactRedundancy, } from "./linting/core";
+import { defaultContainerQueryValidation } from "./validation";
+import { createContainerQueryBuilder } from "./helpers";
+export const createEmitCoreFeatures = (validation) => (props, helpers) => {
+    const allowQueryArrays = helpers.config.allowQueryArrays !== false;
+    const assertNoArray = (value, label) => {
+        if (Array.isArray(value) && !allowQueryArrays) {
+            throw new Error(`${label} does not allow arrays.`);
+        }
+    };
+    const emitFeature = (name, value) => {
+        if (Array.isArray(value)) {
+            value.forEach((entry) => {
+                var _a;
+                ((_a = helpers.addFeatureUnsafe) !== null && _a !== void 0 ? _a : helpers.addFeature)(name, entry);
+            });
+            return;
+        }
+        helpers.addFeature(name, value);
+    };
+    const { runContainerQueryValidation, validateMinMaxWidth, validateWidthValuesPositive, validateMinMaxHeight, validateHeightValuesPositive, } = validation;
+    if (!runContainerQueryValidation(props, helpers, validateMinMaxWidth, "core", "minWidth must be less than or equal to maxWidth")) {
+        return;
+    }
+    if (!runContainerQueryValidation(props, helpers, validateMinMaxHeight, "core", "minHeight must be less than or equal to maxHeight")) {
+        return;
+    }
+    if (!runContainerQueryValidation(props, helpers, validateWidthValuesPositive, "core", "width values must be greater than 0")) {
+        return;
+    }
+    if (!runContainerQueryValidation(props, helpers, validateHeightValuesPositive, "core", "height values must be greater than 0")) {
+        return;
+    }
+    if (!runContainerQueryLint(props, helpers, lintWidthExactRedundancy, "minWidth should not be combined with maxWidth when both are equal")) {
+        return;
+    }
+    if (!runContainerQueryLint(props, helpers, lintHeightExactRedundancy, "minHeight should not be combined with maxHeight when both are equal")) {
+        return;
+    }
+    if (props.minWidth !== undefined) {
+        assertNoArray(props.minWidth, "minWidth");
+        emitFeature("min-width", props.minWidth);
+    }
+    if (props.maxWidth !== undefined) {
+        assertNoArray(props.maxWidth, "maxWidth");
+        emitFeature("max-width", props.maxWidth);
+    }
+    if (props.minHeight !== undefined) {
+        assertNoArray(props.minHeight, "minHeight");
+        emitFeature("min-height", props.minHeight);
+    }
+    if (props.maxHeight !== undefined) {
+        assertNoArray(props.maxHeight, "maxHeight");
+        emitFeature("max-height", props.maxHeight);
+    }
+};
+export const emitCoreFeatures = createEmitCoreFeatures(defaultContainerQueryValidation);
+const emitBaseFeatures = (props, helpers) => {
+    emitCoreFeatures(props, helpers);
+    emitAspectRatioFeatures(props, helpers);
+    emitInlineSizeFeatures(props, helpers);
+    emitBlockSizeFeatures(props, helpers);
+    emitStyleFeatures(props, helpers);
+    emitCustomFeatures(props, helpers);
+};
+export const buildContainerQueryString = createContainerQueryBuilder({
+    emitBase: emitBaseFeatures,
+});
+const wrapContainerCondition = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.includes(" and ") ||
+        trimmed.includes(" or ") ||
+        trimmed.startsWith("not ")) {
+        return `(${trimmed})`;
+    }
+    return trimmed;
+};
+export const buildContainerConditionString = (condition) => {
+    if ("and" in condition) {
+        return condition.and
+            .map((entry) => wrapContainerCondition(buildContainerConditionString(entry)))
+            .join(" and ");
+    }
+    if ("or" in condition) {
+        return condition.or
+            .map((entry) => wrapContainerCondition(buildContainerConditionString(entry)))
+            .join(" or ");
+    }
+    if ("not" in condition) {
+        return `not ${wrapContainerCondition(buildContainerConditionString(condition.not))}`;
+    }
+    return buildContainerQueryString(condition);
+};
+export const makeContainerQueryStyle = (queries) => (stylesByQuery) => {
+    const result = {};
+    Object.keys(stylesByQuery).forEach((key) => {
+        const styles = stylesByQuery[key];
+        const props = queries[key];
+        if (!styles || !props)
+            return;
+        result[buildContainerQueryString(props)] = styles;
+    });
+    const containerQuery = {
+        "@container": result,
+    };
+    return containerQuery;
+};

package/dist/esm/containerQueries/factory.d.ts

@@ -0,0 +1,20 @@
+import type { ComplexStyleRule, StyleRule } from "../mediaQueries/types";
+import type { CSSContainerQueries } from "./types";
+import type { ContainerQueryBuilderConfig } from "./helpers";
+import type { ContainerQueryModulesList } from "./moduleRegistry";
+type ContainerQueryStyleMap<TQueries> = Partial<Record<keyof TQueries, StyleRule>>;
+export type ContainerQueryFactoryConfig<TModules extends ContainerQueryModulesList | undefined = undefined, TOutput = ComplexStyleRule> = ContainerQueryBuilderConfig & {
+    label: string;
+    modules?: TModules;
+    output?: (container: ComplexStyleRule) => TOutput;
+};
+export declare const createContainerQueryFactory: () => <TModules extends ContainerQueryModulesList | undefined, TQueries extends CSSContainerQueries, TOutput = ComplexStyleRule>(options: {
+    queries: TQueries;
+    config: ContainerQueryFactoryConfig<TModules, TOutput>;
+}) => (stylesByQuery: ContainerQueryStyleMap<TQueries>) => TOutput;
+export declare const containerQueryFactory: <TModules extends ContainerQueryModulesList | undefined, TQueries extends CSSContainerQueries, TOutput = ComplexStyleRule>(options: {
+    queries: TQueries;
+    config: ContainerQueryFactoryConfig<TModules, TOutput>;
+}) => (stylesByQuery: ContainerQueryStyleMap<TQueries>) => TOutput;
+export {};
+//# sourceMappingURL=factory.d.ts.map

package/dist/esm/containerQueries/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/containerQueries/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACV,2BAA2B,EAC5B,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAEV,yBAAyB,EAC1B,MAAM,kBAAkB,CAAC;AAE1B,KAAK,sBAAsB,CAAC,QAAQ,IAAI,OAAO,CAC7C,MAAM,CAAC,MAAM,QAAQ,EAAE,SAAS,CAAC,CAClC,CAAC;AAqIF,MAAM,MAAM,2BAA2B,CACrC,QAAQ,SAAS,yBAAyB,GAAG,SAAS,GAAG,SAAS,EAClE,OAAO,GAAG,gBAAgB,IACxB,2BAA2B,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,gBAAgB,KAAK,OAAO,CAAC;CACnD,CAAC;AAEF,eAAO,MAAM,2BAA2B,SACtC,QAAQ,SAAS,yBAAyB,GAAG,SAAS,EACtD,QAAQ,SAAS,mBAAmB,EACpC,OAAO,GAAG,gBAAgB,EAC1B,SAAS;IACT,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,EAAE,2BAA2B,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;CACxD,MAGS,eAAe,sBAAsB,CAAC,QAAQ,CAAC,KAAG,OA6B3D,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAxChC,QAAQ,SAAS,yBAAyB,GAAG,SAAS,EACtD,QAAQ,SAAS,mBAAmB,EACpC,OAAO,8BACE;IACT,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,EAAE,2BAA2B,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;CACxD,MAGS,eAAe,sBAAsB,CAAC,QAAQ,CAAC,KAAG,OA+BM,CAAC"}

package/dist/esm/containerQueries/factory.js

@@ -0,0 +1,119 @@
+import { buildContainerConditionString } from "./containerQueries";
+const ALL_CONTAINER_QUERY_MODULES = [
+    "core",
+    "inline",
+    "block",
+    "aspectRatio",
+    "style",
+    "custom",
+];
+const MODULE_KEYS = {
+    core: ["minWidth", "maxWidth", "minHeight", "maxHeight"],
+    inline: ["inlineSize", "inlineSizeRange"],
+    block: ["blockSize", "blockSizeRange"],
+    aspectRatio: ["aspectRatio", "minAspectRatio", "maxAspectRatio"],
+    style: ["style"],
+    custom: ["customFeatures"],
+};
+const KEY_TO_MODULE = Object.fromEntries(Object.keys(MODULE_KEYS).flatMap((moduleId) => MODULE_KEYS[moduleId].map((key) => [key, moduleId])));
+const collectConditionKeys = (condition, keys) => {
+    if ("and" in condition) {
+        condition.and.forEach((entry) => collectConditionKeys(entry, keys));
+        return;
+    }
+    if ("or" in condition) {
+        condition.or.forEach((entry) => collectConditionKeys(entry, keys));
+        return;
+    }
+    if ("not" in condition) {
+        collectConditionKeys(condition.not, keys);
+        return;
+    }
+    Object.keys(condition).forEach((key) => keys.add(key));
+};
+const collectAndConditionKeys = (condition, keys) => {
+    if ("and" in condition) {
+        condition.and.forEach((entry) => collectAndConditionKeys(entry, keys));
+        return;
+    }
+    if ("or" in condition || "not" in condition) {
+        return;
+    }
+    Object.keys(condition).forEach((key) => keys.push(key));
+};
+const guardUnsupportedCondition = (condition, modules, config, label) => {
+    const allowed = new Set();
+    modules.forEach((moduleId) => {
+        MODULE_KEYS[moduleId].forEach((key) => {
+            allowed.add(key);
+        });
+    });
+    const conditionKeys = new Set();
+    collectConditionKeys(condition, conditionKeys);
+    conditionKeys.forEach((key) => {
+        var _a, _b;
+        if (allowed.has(key))
+            return;
+        const mode = (_b = (_a = config.errorHandling) === null || _a === void 0 ? void 0 : _a.invalidValueMode) !== null && _b !== void 0 ? _b : "throw";
+        const moduleHint = KEY_TO_MODULE[key];
+        const moduleSuffix = moduleHint
+            ? ` Add "${moduleHint}" to modules.`
+            : "";
+        const message = `Container query factory "${label}" received unsupported feature "${key}".${moduleSuffix}`;
+        if (mode === "log") {
+            console.warn(message);
+            return;
+        }
+        if (mode === "allow")
+            return;
+        throw new Error(message);
+    });
+};
+const guardDuplicateConditions = (condition, config, label) => {
+    var _a, _b;
+    const keys = [];
+    collectAndConditionKeys(condition, keys);
+    const seen = new Set();
+    const duplicates = new Set();
+    keys.forEach((key) => {
+        if (seen.has(key)) {
+            duplicates.add(key);
+            return;
+        }
+        seen.add(key);
+    });
+    if (!duplicates.size)
+        return;
+    const mode = (_b = (_a = config.errorHandling) === null || _a === void 0 ? void 0 : _a.invalidValueMode) !== null && _b !== void 0 ? _b : "throw";
+    const message = `Container query factory "${label}" received duplicate condition "${Array.from(duplicates).join('", "')}".`;
+    if (mode === "log") {
+        console.warn(message);
+        return;
+    }
+    if (mode === "allow")
+        return;
+    throw new Error(message);
+};
+export const createContainerQueryFactory = () => (options) => {
+    var _a;
+    const modules = (_a = options.config.modules) !== null && _a !== void 0 ? _a : ALL_CONTAINER_QUERY_MODULES;
+    return (stylesByQuery) => {
+        const result = {};
+        Object.keys(stylesByQuery).forEach((key) => {
+            const styles = stylesByQuery[key];
+            const rule = options.queries[key];
+            if (!styles || !(rule === null || rule === void 0 ? void 0 : rule.query))
+                return;
+            guardUnsupportedCondition(rule.query.condition, modules, options.config, options.config.label);
+            guardDuplicateConditions(rule.query.condition, options.config, options.config.label);
+            result[buildContainerConditionString(rule.query.condition)] = styles;
+        });
+        const containerQuery = {
+            "@container": result,
+        };
+        return options.config.output
+            ? options.config.output(containerQuery)
+            : containerQuery;
+    };
+};
+export const containerQueryFactory = createContainerQueryFactory();

package/dist/esm/containerQueries/helpers.d.ts

@@ -0,0 +1,53 @@
+import type { IRatio } from "../ratio";
+import type { IMeasurement } from "../core";
+import type { ComparisonValue } from "../comparisons";
+import type { CSSComparison, CSSRange } from "./types";
+import type { ValidationResult } from "../validation";
+export type ContainerQueryValidationResult = ValidationResult;
+export type ContainerQueryValidator<TConfig> = (config: TConfig) => ContainerQueryValidationResult;
+type ContainerQueryFeatureValue = string | number | IMeasurement | IRatio;
+type ContainerQueryFeatureEmitter = (name: string, value: ContainerQueryFeatureValue) => void;
+type ContainerQueryConditionEmitter = (condition: string) => void;
+export type ContainerQueryInvalidValueMode = "allow" | "log" | "throw";
+export type ContainerQueryLintingMode = "allow" | "log" | "throw";
+export type ContainerQueryBuilderConfig = {
+    errorHandling?: {
+        invalidValueMode?: ContainerQueryInvalidValueMode;
+        lintingMode?: ContainerQueryLintingMode;
+    };
+    allowQueryArrays?: boolean;
+};
+export interface ContainerQueryBuilderHelpers {
+    addFeature: ContainerQueryFeatureEmitter;
+    addFeatureUnsafe: ContainerQueryFeatureEmitter;
+    addCondition: ContainerQueryConditionEmitter;
+    config: ContainerQueryBuilderConfig;
+}
+export type ContainerQueryExtensionHandler<TConfig> = (config: TConfig, helpers: ContainerQueryBuilderHelpers) => void;
+type ContainerQueryBuilderOptions<TConfig> = {
+    emitBase: ContainerQueryExtensionHandler<TConfig>;
+    emitExtensions?: ContainerQueryExtensionHandler<TConfig>;
+    resolveType?: (config: TConfig) => "all" | "print" | "screen" | undefined;
+    config?: ContainerQueryBuilderConfig;
+};
+export declare const formatContainerQueryValue: (value: ContainerQueryFeatureValue) => string;
+type ContainerQueryRangeMode = "min" | "max";
+type ContainerQueryRangeOptions = {
+    mode?: ContainerQueryRangeMode;
+    inclusive?: boolean;
+};
+export declare const buildContainerComparison: <TValue>(comparison: ComparisonValue<TValue>) => CSSComparison<TValue>;
+export declare const buildContainerRange: <TValue>(min: TValue, max: TValue, options?: ContainerQueryRangeOptions) => CSSRange<TValue>;
+export declare const buildContainerQueryStringFromParts: (parts: string[]) => string;
+export declare const formatContainerQueryComparison: (name: string, operator: string, value: ContainerQueryFeatureValue) => string;
+export declare const createContainerQueryFeatureEmitter: (parts: string[]) => ContainerQueryFeatureEmitter;
+export declare const createContainerQueryConditionEmitter: (parts: string[]) => ContainerQueryConditionEmitter;
+type ContainerQueryFeatureEmitterOptions = {
+    emitted?: Set<string>;
+    lintingMode?: ContainerQueryLintingMode;
+};
+export declare const createContainerQueryFeatureEmitterWithTracking: (parts: string[], options?: ContainerQueryFeatureEmitterOptions) => ContainerQueryFeatureEmitter;
+export declare const createContainerQueryBuilder: <TConfig>(options: ContainerQueryBuilderOptions<TConfig>) => (config: TConfig) => string;
+export declare const applyContainerQueryValidation: <TConfig>(config: TConfig, helpers: ContainerQueryBuilderHelpers, validator?: ContainerQueryValidator<TConfig>, context?: string) => boolean;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/containerQueries/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/containerQueries/helpers.ts"],"names":[],"mappings":"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"}

package/dist/esm/containerQueries/helpers.js

@@ -0,0 +1,82 @@
+import { hasCssMethod } from "../core";
+import { normalizeValidationResult } from "../validation";
+export const formatContainerQueryValue = (value) => (hasCssMethod(value) ? value.css() : String(value));
+export const buildContainerComparison = (comparison) => comparison;
+export const buildContainerRange = (min, max, options = {}) => {
+    var _a;
+    const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : "min";
+    const operator = options.inclusive === false ? "<" : "<=";
+    if (mode === "max") {
+        return { min, max, maxOperator: operator };
+    }
+    return { min, max, minOperator: operator };
+};
+export const buildContainerQueryStringFromParts = (parts) => parts.join(" and ");
+export const formatContainerQueryComparison = (name, operator, value) => {
+    return `(${name} ${operator} ${formatContainerQueryValue(value)})`;
+};
+export const createContainerQueryFeatureEmitter = (parts) => (name, value) => {
+    parts.push(`(${name}: ${formatContainerQueryValue(value)})`);
+};
+export const createContainerQueryConditionEmitter = (parts) => (condition) => {
+    parts.push(condition);
+};
+export const createContainerQueryFeatureEmitterWithTracking = (parts, options = {}) => {
+    const { emitted, lintingMode = "throw" } = options;
+    return (name, value) => {
+        if (emitted === null || emitted === void 0 ? void 0 : emitted.has(name)) {
+            if (lintingMode === "throw") {
+                throw new Error(`Container query feature "${name}" was emitted more than once.`);
+            }
+            if (lintingMode === "log") {
+                console.warn(`Container query feature "${name}" was emitted more than once; using the latest value.`);
+            }
+        }
+        emitted === null || emitted === void 0 ? void 0 : emitted.add(name);
+        parts.push(`(${name}: ${formatContainerQueryValue(value)})`);
+    };
+};
+export const createContainerQueryBuilder = (options) => {
+    return (config) => {
+        var _a, _b, _c, _d, _e;
+        const parts = [];
+        const emittedFeatures = new Set();
+        const helpers = {
+            addFeature: createContainerQueryFeatureEmitterWithTracking(parts, {
+                emitted: emittedFeatures,
+                lintingMode: (_c = (_b = (_a = options.config) === null || _a === void 0 ? void 0 : _a.errorHandling) === null || _b === void 0 ? void 0 : _b.lintingMode) !== null && _c !== void 0 ? _c : "throw",
+            }),
+            addFeatureUnsafe: createContainerQueryFeatureEmitter(parts),
+            addCondition: createContainerQueryConditionEmitter(parts),
+            config: (_d = options.config) !== null && _d !== void 0 ? _d : {},
+        };
+        options.emitBase(config, helpers);
+        (_e = options.emitExtensions) === null || _e === void 0 ? void 0 : _e.call(options, config, helpers);
+        return buildContainerQueryStringFromParts(parts);
+    };
+};
+export const applyContainerQueryValidation = (config, helpers, validator, context) => {
+    var _a, _b;
+    if (!validator)
+        return true;
+    const normalized = normalizeValidationResult(validator(config));
+    if (normalized.valid)
+        return true;
+    const mode = (_b = (_a = helpers.config.errorHandling) === null || _a === void 0 ? void 0 : _a.invalidValueMode) !== null && _b !== void 0 ? _b : "throw";
+    if (mode === "log") {
+        const suffix = normalized.message ? `: ${normalized.message}` : "";
+        const prefix = context
+            ? `Container query ${context} validation failed`
+            : "Container query validation failed";
+        console.warn(`${prefix}${suffix}`);
+    }
+    if (mode === "allow")
+        return true;
+    if (mode === "log")
+        return true;
+    const suffix = normalized.message ? `: ${normalized.message}` : "";
+    const prefix = context
+        ? `Container query ${context} validation failed`
+        : "Container query validation failed";
+    throw new Error(`${prefix}${suffix}`);
+};

package/dist/esm/containerQueries/index.d.ts

@@ -0,0 +1,10 @@
+export { buildContainerConditionString, buildContainerQueryString, makeContainerQueryStyle, } from "./containerQueries";
+export { buildContainerComparison, buildContainerRange, formatContainerQueryValue, } from "./helpers";
+export { containerQueryFactory, createContainerQueryFactory } from "./factory";
+export { defineContainerQueryModules } from "./moduleRegistry";
+export type * from "./types";
+export type * from "./containerQueries";
+export type * from "./factory";
+export type * from "./modules";
+export type * from "./moduleRegistry";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/containerQueries/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/containerQueries/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,mBAAmB,SAAS,CAAC;AAC7B,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,WAAW,CAAC;AAC/B,mBAAmB,WAAW,CAAC;AAC/B,mBAAmB,kBAAkB,CAAC"}

package/dist/esm/containerQueries/index.js

@@ -0,0 +1,4 @@
+export { buildContainerConditionString, buildContainerQueryString, makeContainerQueryStyle, } from "./containerQueries";
+export { buildContainerComparison, buildContainerRange, formatContainerQueryValue, } from "./helpers";
+export { containerQueryFactory, createContainerQueryFactory } from "./factory";
+export { defineContainerQueryModules } from "./moduleRegistry";

package/dist/esm/containerQueries/linting/aspectRatio.d.ts

@@ -0,0 +1,4 @@
+import type { IContainerQueryAspectRatio } from "../modules/aspectRatio";
+export declare const lintAspectRatioRedundancy: (props: IContainerQueryAspectRatio) => void;
+export declare const lintAspectRatioRangeCollapse: (props: IContainerQueryAspectRatio) => void;
+//# sourceMappingURL=aspectRatio.d.ts.map

package/dist/esm/containerQueries/linting/aspectRatio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aspectRatio.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/aspectRatio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAGzE,eAAO,MAAM,yBAAyB,GACpC,OAAO,0BAA0B,KAChC,IAOF,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,OAAO,0BAA0B,KAChC,IAeF,CAAC"}

package/dist/esm/containerQueries/linting/aspectRatio.js

@@ -0,0 +1,19 @@
+import { ratioToFloat } from "../../ratio";
+export const lintAspectRatioRedundancy = (props) => {
+    if (!props.aspectRatio)
+        return;
+    if (props.minAspectRatio || props.maxAspectRatio) {
+        throw new Error("aspectRatio should not be combined with minAspectRatio or maxAspectRatio");
+    }
+};
+export const lintAspectRatioRangeCollapse = (props) => {
+    if (!props.minAspectRatio || !props.maxAspectRatio)
+        return;
+    if (Array.isArray(props.minAspectRatio) ||
+        Array.isArray(props.maxAspectRatio)) {
+        return;
+    }
+    if (ratioToFloat(props.minAspectRatio) === ratioToFloat(props.maxAspectRatio)) {
+        throw new Error("minAspectRatio and maxAspectRatio are equal; use aspectRatio instead");
+    }
+};

package/dist/esm/containerQueries/linting/block.d.ts

@@ -0,0 +1,4 @@
+import type { IContainerQueryBlock } from "../modules/block";
+export declare const lintBlockRedundancy: (props: IContainerQueryBlock) => void;
+export declare const lintBlockRangeCollapse: (props: IContainerQueryBlock) => void;
+//# sourceMappingURL=block.d.ts.map

package/dist/esm/containerQueries/linting/block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/block.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAG7D,eAAO,MAAM,mBAAmB,GAC9B,OAAO,oBAAoB,KAC1B,IAOF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,OAAO,oBAAoB,KAC1B,IAUF,CAAC"}

package/dist/esm/containerQueries/linting/block.js

@@ -0,0 +1,18 @@
+import { normalizeToArray } from "../../internal/normalizeToArray";
+export const lintBlockRedundancy = (props) => {
+    if (!props.blockSize)
+        return;
+    if (props.blockSizeRange) {
+        throw new Error("blockSize should not be combined with blockSizeRange");
+    }
+};
+export const lintBlockRangeCollapse = (props) => {
+    if (!props.blockSizeRange)
+        return;
+    normalizeToArray(props.blockSizeRange).forEach((range) => {
+        const { min, max } = range;
+        if (min.equals(max)) {
+            throw new Error("blockSizeRange min and max are equal; use blockSize instead");
+        }
+    });
+};

package/dist/esm/containerQueries/linting/core.d.ts

@@ -0,0 +1,4 @@
+import type { IContainerQueryCore } from "../containerQueries";
+export declare const lintWidthExactRedundancy: (props: IContainerQueryCore) => void;
+export declare const lintHeightExactRedundancy: (props: IContainerQueryCore) => void;
+//# sourceMappingURL=core.d.ts.map

package/dist/esm/containerQueries/linting/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,KACzB,IAUF,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,OAAO,mBAAmB,KACzB,IAUF,CAAC"}

package/dist/esm/containerQueries/linting/core.js

@@ -0,0 +1,20 @@
+export const lintWidthExactRedundancy = (props) => {
+    if (!props.minWidth || !props.maxWidth)
+        return;
+    if (Array.isArray(props.minWidth) || Array.isArray(props.maxWidth)) {
+        return;
+    }
+    if (props.minWidth.equals(props.maxWidth)) {
+        throw new Error("minWidth should not be combined with maxWidth when both are equal");
+    }
+};
+export const lintHeightExactRedundancy = (props) => {
+    if (!props.minHeight || !props.maxHeight)
+        return;
+    if (Array.isArray(props.minHeight) || Array.isArray(props.maxHeight)) {
+        return;
+    }
+    if (props.minHeight.equals(props.maxHeight)) {
+        throw new Error("minHeight should not be combined with maxHeight when both are equal");
+    }
+};

package/dist/esm/containerQueries/linting/custom.d.ts

@@ -0,0 +1,3 @@
+import type { IContainerQueryCustomFeatures } from "../modules/custom";
+export declare const lintCustomFeatures: (props: IContainerQueryCustomFeatures) => void;
+//# sourceMappingURL=custom.d.ts.map

package/dist/esm/containerQueries/linting/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/custom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAEvE,eAAO,MAAM,kBAAkB,GAC7B,OAAO,6BAA6B,KACnC,IAKF,CAAC"}

package/dist/esm/containerQueries/linting/custom.js

@@ -0,0 +1,7 @@
+export const lintCustomFeatures = (props) => {
+    if (!props.customFeatures)
+        return;
+    if (!Object.keys(props.customFeatures).length) {
+        throw new Error("customFeatures should not be empty.");
+    }
+};

package/dist/esm/containerQueries/linting/inline.d.ts

@@ -0,0 +1,4 @@
+import type { IContainerQueryInline } from "../modules/inline";
+export declare const lintInlineRedundancy: (props: IContainerQueryInline) => void;
+export declare const lintInlineRangeCollapse: (props: IContainerQueryInline) => void;
+//# sourceMappingURL=inline.d.ts.map

package/dist/esm/containerQueries/linting/inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/inline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG/D,eAAO,MAAM,oBAAoB,GAC/B,OAAO,qBAAqB,KAC3B,IAOF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,OAAO,qBAAqB,KAC3B,IAUF,CAAC"}

package/dist/esm/containerQueries/linting/inline.js

@@ -0,0 +1,18 @@
+import { normalizeToArray } from "../../internal/normalizeToArray";
+export const lintInlineRedundancy = (props) => {
+    if (!props.inlineSize)
+        return;
+    if (props.inlineSizeRange) {
+        throw new Error("inlineSize should not be combined with inlineSizeRange");
+    }
+};
+export const lintInlineRangeCollapse = (props) => {
+    if (!props.inlineSizeRange)
+        return;
+    normalizeToArray(props.inlineSizeRange).forEach((range) => {
+        const { min, max } = range;
+        if (min.equals(max)) {
+            throw new Error("inlineSizeRange min and max are equal; use inlineSize instead");
+        }
+    });
+};

package/dist/esm/containerQueries/linting/resolution.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=resolution.d.ts.map

package/dist/esm/containerQueries/linting/resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/resolution.ts"],"names":[],"mappings":""}

package/dist/esm/containerQueries/linting/resolution.js

@@ -0,0 +1,12 @@
+"use strict";
+// import type { IMediaQueryResolutionRange } from '../modules/resolution';
+// export const lintResolutionRedundancy = (
+//   props: IMediaQueryResolutionRange,
+// ): void => {
+//   if (!props.resolutionValue) return;
+//   if (props.minResolution || props.maxResolution) {
+//     throw new Error(
+//       'resolution should not be combined with minResolution or maxResolution',
+//     );
+//   }
+// };

package/dist/esm/containerQueries/linting/style.d.ts

@@ -0,0 +1,3 @@
+import type { IContainerQueryStyle } from "../modules/style";
+export declare const lintStyleCondition: (props: IContainerQueryStyle) => void;
+//# sourceMappingURL=style.d.ts.map

package/dist/esm/containerQueries/linting/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../../../src/containerQueries/linting/style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAO7D,eAAO,MAAM,kBAAkB,GAC7B,OAAO,oBAAoB,KAC1B,IAiBF,CAAC"}

package/dist/esm/containerQueries/linting/style.js

@@ -0,0 +1,24 @@
+import { hasCssMethod } from "../../core";
+const isComparisonShape = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return "operator" in value && "value" in value;
+};
+export const lintStyleCondition = (props) => {
+    if (!props.style)
+        return;
+    if (!Object.keys(props.style).length) {
+        throw new Error("style conditions must not be empty.");
+    }
+    Object.values(props.style).forEach((value) => {
+        if (value === undefined || value === null)
+            return;
+        if (Array.isArray(value))
+            return;
+        if (hasCssMethod(value))
+            return;
+        if (isComparisonShape(value)) {
+            throw new Error("style conditions must not contain comparisons.");
+        }
+    });
+};

package/dist/esm/containerQueries/linting.d.ts

@@ -0,0 +1,4 @@
+import type { ContainerQueryBuilderHelpers } from "./helpers";
+export type ContainerQueryLintCheck<TConfig> = (config: TConfig) => void;
+export declare const runContainerQueryLint: <TConfig>(config: TConfig, helpers: ContainerQueryBuilderHelpers, check?: ContainerQueryLintCheck<TConfig>, message?: string) => boolean;
+//# sourceMappingURL=linting.d.ts.map

package/dist/esm/containerQueries/linting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linting.d.ts","sourceRoot":"","sources":["../../../src/containerQueries/linting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAE7B,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,uBAAuB,CAAC,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;AAEzE,eAAO,MAAM,qBAAqB,GAAI,OAAO,EAC3C,QAAQ,OAAO,EACf,SAAS,4BAA4B,EACrC,QAAQ,uBAAuB,CAAC,OAAO,CAAC,EACxC,gBAAuC,KACtC,OAiBF,CAAC"}

package/dist/esm/containerQueries/linting.js

@@ -0,0 +1,20 @@
+export const runContainerQueryLint = (config, helpers, check, message = "Container query lint failed") => {
+    var _a, _b;
+    if (!check)
+        return true;
+    const mode = (_b = (_a = helpers.config.errorHandling) === null || _a === void 0 ? void 0 : _a.lintingMode) !== null && _b !== void 0 ? _b : "throw";
+    if (mode === "allow")
+        return true;
+    if (mode === "log") {
+        try {
+            check(config);
+            return true;
+        }
+        catch {
+            console.warn(message);
+            return true;
+        }
+    }
+    check(config);
+    return true;
+};