css-calipers 0.9.3 → 0.9.5

package/dist/cjs/containerQueries/modules/aspectRatio.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitAspectRatioFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const aspectRatio_1 = require("../linting/aspectRatio");
+const emitAspectRatioFeatures = (props, helpers, validate) => {
+    const allowQueryArrays = helpers.config.allowQueryArrays !== false;
+    const assertNoArray = (value, label) => {
+        if (Array.isArray(value) && !allowQueryArrays) {
+            throw new Error(`${label} does not allow arrays.`);
+        }
+    };
+    const { runContainerQueryValidation, validateAspectRatioValues } = validation_1.defaultContainerQueryValidation;
+    if (!runContainerQueryValidation(props, helpers, validateAspectRatioValues, "aspectRatio", "aspect ratio values must be valid ratio greater than 0")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, aspectRatio_1.lintAspectRatioRedundancy, "aspectRatio should not be combined with minAspectRatio or maxAspectRatio")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, aspectRatio_1.lintAspectRatioRangeCollapse, "minAspectRatio and maxAspectRatio are equal; use aspectRatio instead")) {
+        return;
+    }
+    if (!(0, helpers_1.applyContainerQueryValidation)(props, helpers, validate, "aspectRatio")) {
+        return;
+    }
+    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);
+    };
+    if (props.aspectRatio !== undefined) {
+        assertNoArray(props.aspectRatio, "aspectRatio");
+        emitFeature("aspect-ratio", props.aspectRatio);
+    }
+    if (props.minAspectRatio !== undefined) {
+        assertNoArray(props.minAspectRatio, "minAspectRatio");
+        emitFeature("min-aspect-ratio", props.minAspectRatio);
+    }
+    if (props.maxAspectRatio !== undefined) {
+        assertNoArray(props.maxAspectRatio, "maxAspectRatio");
+        emitFeature("max-aspect-ratio", props.maxAspectRatio);
+    }
+};
+exports.emitAspectRatioFeatures = emitAspectRatioFeatures;

package/dist/cjs/containerQueries/modules/block.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitBlockSizeFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const block_1 = require("../linting/block");
+const normalizeToArray_1 = require("../../internal/normalizeToArray");
+const emitBlockComparison = (name, comparison, addCondition) => {
+    addCondition((0, helpers_1.formatContainerQueryComparison)(name, comparison.operator, comparison.value));
+};
+const emitBlockRange = (name, range, addCondition) => {
+    const min = (0, helpers_1.formatContainerQueryValue)(range.min);
+    const max = (0, helpers_1.formatContainerQueryValue)(range.max);
+    if ("minOperator" in range) {
+        addCondition(`(${min} ${range.minOperator} ${name})`);
+        addCondition(`(${name} <= ${max})`);
+        return;
+    }
+    addCondition(`(${min} <= ${name})`);
+    addCondition(`(${name} ${range.maxOperator} ${max})`);
+};
+const emitBlockSizeFeatures = (props, helpers, validate) => {
+    const allowQueryArrays = helpers.config.allowQueryArrays !== false;
+    const assertNoArray = (value, label) => {
+        if (Array.isArray(value) && !allowQueryArrays) {
+            throw new Error(`${label} does not allow arrays.`);
+        }
+    };
+    const { runContainerQueryValidation, validateBlockSizeValues, } = validation_1.defaultContainerQueryValidation;
+    if (!runContainerQueryValidation(props, helpers, validateBlockSizeValues, "block", "block size values must be valid measurements greater than 0")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, block_1.lintBlockRedundancy, "blockSize should not be combined with blockSizeRange")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, block_1.lintBlockRangeCollapse, "blockSizeRange min and max are equal; use blockSize instead")) {
+        return;
+    }
+    if (!(0, helpers_1.applyContainerQueryValidation)(props, helpers, validate, "block")) {
+        return;
+    }
+    const { addCondition } = helpers;
+    assertNoArray(props.blockSize, "blockSize");
+    (0, normalizeToArray_1.normalizeToArray)(props.blockSize).forEach((value) => {
+        emitBlockComparison("block-size", value, addCondition);
+    });
+    assertNoArray(props.blockSizeRange, "blockSizeRange");
+    (0, normalizeToArray_1.normalizeToArray)(props.blockSizeRange).forEach((value) => {
+        emitBlockRange("block-size", value, addCondition);
+    });
+};
+exports.emitBlockSizeFeatures = emitBlockSizeFeatures;

package/dist/cjs/containerQueries/modules/custom.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitCustomFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const custom_1 = require("../linting/custom");
+const normalizeToArray_1 = require("../../internal/normalizeToArray");
+const emitCustomFeatures = (props, helpers, options, validate) => {
+    var _a, _b;
+    const { runContainerQueryValidation, validateCustomFeatures } = validation_1.defaultContainerQueryValidation;
+    if (!runContainerQueryValidation(props, helpers, validateCustomFeatures, "custom", "custom features must be valid and non-empty")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, custom_1.lintCustomFeatures, "customFeatures should not be empty")) {
+        return;
+    }
+    if (!(0, helpers_1.applyContainerQueryValidation)(props, helpers, validate, "custom")) {
+        return;
+    }
+    const { addFeatureUnsafe, addFeature } = helpers;
+    const allowQueryArrays = (_b = (_a = options === null || options === void 0 ? void 0 : options.allowQueryArrays) !== null && _a !== void 0 ? _a : helpers.config.allowQueryArrays) !== null && _b !== void 0 ? _b : true;
+    if (!props.customFeatures)
+        return;
+    Object.entries(props.customFeatures).forEach(([name, value]) => {
+        if (value === undefined || value === null)
+            return;
+        const trimmedName = name.trim();
+        if (!trimmedName)
+            return;
+        if (Array.isArray(value) && !allowQueryArrays) {
+            throw new Error(`Custom feature "${trimmedName}" does not allow arrays.`);
+        }
+        if (Array.isArray(value)) {
+            (0, normalizeToArray_1.normalizeToArray)(value).forEach((entry) => {
+                (addFeatureUnsafe !== null && addFeatureUnsafe !== void 0 ? addFeatureUnsafe : addFeature)(trimmedName, entry);
+            });
+            return;
+        }
+        addFeature(trimmedName, value);
+    });
+};
+exports.emitCustomFeatures = emitCustomFeatures;

package/dist/cjs/containerQueries/modules/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aspectRatio"), exports);
+__exportStar(require("./block"), exports);
+__exportStar(require("./custom"), exports);
+__exportStar(require("./inline"), exports);
+__exportStar(require("./style"), exports);

package/dist/cjs/containerQueries/modules/inline.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitInlineSizeFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const inline_1 = require("../linting/inline");
+const normalizeToArray_1 = require("../../internal/normalizeToArray");
+const emitInlineComparison = (name, comparison, addCondition) => {
+    addCondition((0, helpers_1.formatContainerQueryComparison)(name, comparison.operator, comparison.value));
+};
+const emitInlineRange = (name, range, addCondition) => {
+    const min = (0, helpers_1.formatContainerQueryValue)(range.min);
+    const max = (0, helpers_1.formatContainerQueryValue)(range.max);
+    if ("minOperator" in range) {
+        addCondition(`(${min} ${range.minOperator} ${name})`);
+        addCondition(`(${name} <= ${max})`);
+        return;
+    }
+    addCondition(`(${min} <= ${name})`);
+    addCondition(`(${name} ${range.maxOperator} ${max})`);
+};
+const emitInlineSizeFeatures = (props, helpers, validate) => {
+    const allowQueryArrays = helpers.config.allowQueryArrays !== false;
+    const assertNoArray = (value, label) => {
+        if (Array.isArray(value) && !allowQueryArrays) {
+            throw new Error(`${label} does not allow arrays.`);
+        }
+    };
+    const { runContainerQueryValidation, validateInlineSizeValues, } = validation_1.defaultContainerQueryValidation;
+    if (!runContainerQueryValidation(props, helpers, validateInlineSizeValues, "inline", "inline size values must be valid measurements greater than 0")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, inline_1.lintInlineRedundancy, "inlineSize should not be combined with inlineSizeRange")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, inline_1.lintInlineRangeCollapse, "inlineSizeRange min and max are equal; use inlineSize instead")) {
+        return;
+    }
+    if (!(0, helpers_1.applyContainerQueryValidation)(props, helpers, validate, "inline")) {
+        return;
+    }
+    const { addCondition } = helpers;
+    assertNoArray(props.inlineSize, "inlineSize");
+    (0, normalizeToArray_1.normalizeToArray)(props.inlineSize).forEach((value) => {
+        emitInlineComparison("inline-size", value, addCondition);
+    });
+    assertNoArray(props.inlineSizeRange, "inlineSizeRange");
+    (0, normalizeToArray_1.normalizeToArray)(props.inlineSizeRange).forEach((value) => {
+        emitInlineRange("inline-size", value, addCondition);
+    });
+};
+exports.emitInlineSizeFeatures = emitInlineSizeFeatures;

package/dist/cjs/containerQueries/modules/size.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/containerQueries/modules/style.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitStyleFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const style_1 = require("../linting/style");
+const emitStyleFeatures = (props, helpers, validate) => {
+    const { runContainerQueryValidation, validateStyleValues, } = validation_1.defaultContainerQueryValidation;
+    if (!runContainerQueryValidation(props, helpers, validateStyleValues, "style", "style conditions must be valid and non-empty")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, style_1.lintStyleCondition, "style conditions must be valid and non-empty")) {
+        return;
+    }
+    if (!(0, helpers_1.applyContainerQueryValidation)(props, helpers, validate, "style")) {
+        return;
+    }
+    if (!props.style)
+        return;
+    const { addCondition } = helpers;
+    Object.entries(props.style).forEach(([name, value]) => {
+        if (value === undefined || value === null)
+            return;
+        if (Array.isArray(value)) {
+            value.forEach((entry) => {
+                if (entry === undefined || entry === null)
+                    return;
+                addCondition(`(style(${name}: ${(0, helpers_1.formatContainerQueryValue)(entry)}))`);
+            });
+            return;
+        }
+        addCondition(`(style(${name}: ${(0, helpers_1.formatContainerQueryValue)(value)}))`);
+    });
+};
+exports.emitStyleFeatures = emitStyleFeatures;

package/dist/cjs/containerQueries/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/containerQueries/validation.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultContainerQueryValidation = exports.validateCustomFeatures = exports.validateStyleValues = exports.validateAspectRatioValues = exports.validateBlockSizeValues = exports.validateInlineSizeValues = exports.validateHeightValuesPositive = exports.validateMinMaxHeight = exports.validateWidthValuesPositive = exports.validateMinMaxWidth = exports.runContainerQueryValidation = exports.createContainerQueryValidation = void 0;
+const helpers_1 = require("./helpers");
+const core_1 = require("../core");
+const validation_1 = require("../validation");
+const normalizeToArray_1 = require("../internal/normalizeToArray");
+const ratio_1 = require("../ratio");
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const assertMeasurement = (value, label) => {
+    (0, core_1.assertCondition)((0, core_1.isMeasurement)(value), `${label} must be a measurement`);
+};
+const assertMeasurementPositive = (value, label) => {
+    (0, core_1.assertCondition)(value.getValue() > 0, `${label} must be greater than 0`);
+};
+const assertRatio = (value, label) => {
+    (0, core_1.assertCondition)((0, core_1.isRatio)(value), `${label} must be a ratio created with r()`);
+};
+const assertRatioPositive = (value, label) => {
+    (0, core_1.assertCondition)(value.numerator() > 0, `${label} numerator must be greater than 0`);
+    (0, core_1.assertCondition)(value.denominator() > 0, `${label} denominator must be greater than 0`);
+};
+const isStyleValue = (value) => {
+    if (typeof value === "string")
+        return true;
+    if (isFiniteNumber(value))
+        return true;
+    if ((0, core_1.hasCssMethod)(value))
+        return true;
+    return false;
+};
+const createContainerQueryValidation = (core) => {
+    const assertCondition = core.assertCondition;
+    const assertMatchingUnits = core.assertMatchingUnits;
+    const runContainerQueryValidation = (config, helpers, check, context, fallbackMessage = "Invalid container query configuration") => {
+        if (!check)
+            return true;
+        try {
+            check(config);
+            return true;
+        }
+        catch (error) {
+            const result = (0, validation_1.toValidationResult)(error, fallbackMessage);
+            return (0, helpers_1.applyContainerQueryValidation)(config, helpers, () => result, context);
+        }
+    };
+    const validateMinMaxWidth = (props) => {
+        if (!props.minWidth || !props.maxWidth)
+            return;
+        if (Array.isArray(props.minWidth) || Array.isArray(props.maxWidth)) {
+            return;
+        }
+        assertMatchingUnits(props.minWidth, props.maxWidth, "containerQueries.minMaxWidth");
+        assertCondition(props.minWidth.getValue() <= props.maxWidth.getValue(), "minWidth must be less than or equal to maxWidth");
+    };
+    const validateWidthValuesPositive = (props) => {
+        (0, normalizeToArray_1.normalizeToArray)(props.minWidth).forEach((value) => {
+            assertMeasurement(value, "minWidth");
+            assertMeasurementPositive(value, "minWidth");
+        });
+        (0, normalizeToArray_1.normalizeToArray)(props.maxWidth).forEach((value) => {
+            assertMeasurement(value, "maxWidth");
+            assertMeasurementPositive(value, "maxWidth");
+        });
+    };
+    const validateMinMaxHeight = (props) => {
+        if (!props.minHeight || !props.maxHeight)
+            return;
+        if (Array.isArray(props.minHeight) || Array.isArray(props.maxHeight)) {
+            return;
+        }
+        assertMatchingUnits(props.minHeight, props.maxHeight, "containerQueries.minMaxHeight");
+        assertCondition(props.minHeight.getValue() <= props.maxHeight.getValue(), "minHeight must be less than or equal to maxHeight");
+    };
+    const validateHeightValuesPositive = (props) => {
+        (0, normalizeToArray_1.normalizeToArray)(props.minHeight).forEach((value) => {
+            assertMeasurement(value, "minHeight");
+            assertMeasurementPositive(value, "minHeight");
+        });
+        (0, normalizeToArray_1.normalizeToArray)(props.maxHeight).forEach((value) => {
+            assertMeasurement(value, "maxHeight");
+            assertMeasurementPositive(value, "maxHeight");
+        });
+    };
+    const validateInlineSizeValues = (props) => {
+        (0, normalizeToArray_1.normalizeToArray)(props.inlineSize).forEach((value) => {
+            assertMeasurement(value.value, "inlineSize");
+            assertMeasurementPositive(value.value, "inlineSize");
+        });
+        (0, normalizeToArray_1.normalizeToArray)(props.inlineSizeRange).forEach((value) => {
+            assertMeasurement(value.min, "inlineSizeRange.min");
+            assertMeasurement(value.max, "inlineSizeRange.max");
+            assertMeasurementPositive(value.min, "inlineSizeRange.min");
+            assertMeasurementPositive(value.max, "inlineSizeRange.max");
+            assertMatchingUnits(value.min, value.max, "containerQueries.inlineSizeRangeUnits");
+            assertCondition(value.min.getValue() <= value.max.getValue(), "inlineSizeRange min must be less than or equal to max");
+        });
+    };
+    const validateBlockSizeValues = (props) => {
+        (0, normalizeToArray_1.normalizeToArray)(props.blockSize).forEach((value) => {
+            assertMeasurement(value.value, "blockSize");
+            assertMeasurementPositive(value.value, "blockSize");
+        });
+        (0, normalizeToArray_1.normalizeToArray)(props.blockSizeRange).forEach((value) => {
+            assertMeasurement(value.min, "blockSizeRange.min");
+            assertMeasurement(value.max, "blockSizeRange.max");
+            assertMeasurementPositive(value.min, "blockSizeRange.min");
+            assertMeasurementPositive(value.max, "blockSizeRange.max");
+            assertMatchingUnits(value.min, value.max, "containerQueries.blockSizeRangeUnits");
+            assertCondition(value.min.getValue() <= value.max.getValue(), "blockSizeRange min must be less than or equal to max");
+        });
+    };
+    const validateAspectRatioValues = (props) => {
+        (0, normalizeToArray_1.normalizeToArray)(props.aspectRatio).forEach((value) => {
+            assertRatio(value, "aspectRatio");
+            assertRatioPositive(value, "aspectRatio");
+        });
+        (0, normalizeToArray_1.normalizeToArray)(props.minAspectRatio).forEach((value) => {
+            assertRatio(value, "minAspectRatio");
+            assertRatioPositive(value, "minAspectRatio");
+        });
+        (0, normalizeToArray_1.normalizeToArray)(props.maxAspectRatio).forEach((value) => {
+            assertRatio(value, "maxAspectRatio");
+            assertRatioPositive(value, "maxAspectRatio");
+        });
+        if (props.minAspectRatio &&
+            props.maxAspectRatio &&
+            !Array.isArray(props.minAspectRatio) &&
+            !Array.isArray(props.maxAspectRatio)) {
+            const minValue = (0, ratio_1.ratioToFloat)(props.minAspectRatio);
+            const maxValue = (0, ratio_1.ratioToFloat)(props.maxAspectRatio);
+            assertCondition(minValue <= maxValue, "minAspectRatio must be less than or equal to maxAspectRatio");
+        }
+    };
+    const validateStyleValues = (props) => {
+        if (!props.style)
+            return;
+        const entries = Object.entries(props.style);
+        assertCondition(entries.length > 0, "style conditions must not be empty.");
+        entries.forEach(([name, value]) => {
+            if (value === undefined || value === null)
+                return;
+            if (Array.isArray(value)) {
+                assertCondition(value.length > 0, `style.${name} must not be empty`);
+                value.forEach((entry, index) => {
+                    assertCondition(isStyleValue(entry), `style.${name}[${index}] must be a primitive or measurement`);
+                });
+                return;
+            }
+            assertCondition(isStyleValue(value), `style.${name} must be a primitive or measurement`);
+        });
+    };
+    const validateCustomFeatures = (props) => {
+        if (!props.customFeatures)
+            return;
+        const entries = Object.entries(props.customFeatures);
+        assertCondition(entries.length > 0, "customFeatures should not be empty.");
+        entries.forEach(([name, value]) => {
+            const trimmedName = name.trim();
+            assertCondition(trimmedName.length > 0, "Custom feature name must be non-empty.");
+            if (value === undefined || value === null)
+                return;
+            if (Array.isArray(value)) {
+                value.forEach((entry, index) => {
+                    assertCondition(isStyleValue(entry), `Custom feature "${trimmedName}[${index}]" must be a primitive or a measurement.`);
+                });
+                return;
+            }
+            assertCondition(isStyleValue(value), `Custom feature "${trimmedName}" must be a primitive or a measurement.`);
+        });
+    };
+    return {
+        runContainerQueryValidation,
+        validateMinMaxWidth,
+        validateWidthValuesPositive,
+        validateMinMaxHeight,
+        validateHeightValuesPositive,
+        validateInlineSizeValues,
+        validateBlockSizeValues,
+        validateAspectRatioValues,
+        validateStyleValues,
+        validateCustomFeatures,
+    };
+};
+exports.createContainerQueryValidation = createContainerQueryValidation;
+const defaultContainerQueryValidation = (0, exports.createContainerQueryValidation)({
+    assertCondition: core_1.assertCondition,
+    assertMatchingUnits: core_1.assertMatchingUnits,
+});
+exports.defaultContainerQueryValidation = defaultContainerQueryValidation;
+exports.runContainerQueryValidation = defaultContainerQueryValidation.runContainerQueryValidation, exports.validateMinMaxWidth = defaultContainerQueryValidation.validateMinMaxWidth, exports.validateWidthValuesPositive = defaultContainerQueryValidation.validateWidthValuesPositive, exports.validateMinMaxHeight = defaultContainerQueryValidation.validateMinMaxHeight, exports.validateHeightValuesPositive = defaultContainerQueryValidation.validateHeightValuesPositive, exports.validateInlineSizeValues = defaultContainerQueryValidation.validateInlineSizeValues, exports.validateBlockSizeValues = defaultContainerQueryValidation.validateBlockSizeValues, exports.validateAspectRatioValues = defaultContainerQueryValidation.validateAspectRatioValues, exports.validateStyleValues = defaultContainerQueryValidation.validateStyleValues, exports.validateCustomFeatures = defaultContainerQueryValidation.validateCustomFeatures;