css-calipers 0.9.3 → 0.9.4

package/README.md

@@ -257,6 +257,104 @@ For concrete uses of these errors in tests and dev-only guards, see
 
 ---
 
+## Common errors
+
+### Non-finite measurement value
+
+Example
+
+```
+css-calipers.m: Non-finite measurement value: undefined [code=CALIPERS_E_NONFINITE | helper=m | inputs=value=undefined, unit=px | stack=...]
+```
+
+What it means
+- A measurement was constructed with undefined, NaN, or Infinity.
+
+How to fix
+- Provide a real numeric value and a unit (m(12), m(12, "px")).
+- Add a context label so the error points to the calling helper or token (m(12, { context: "tokens.cardWidth" })).
+
+### Unit mismatch
+
+Example
+
+```
+css-calipers.assertMatchingUnits: measurement unit mismatch: px vs em [code=CALIPERS_E_UNIT_MISMATCH]
+```
+
+What it means
+- You mixed units without an explicit conversion.
+
+How to fix
+- Normalize units at the source (convert em to px or vice versa).
+- Add an assertMatchingUnits call where the values enter your system.
+
+### Divide by zero
+
+Example
+
+```
+css-calipers.Measurement.divide: Cannot divide 10px by zero [code=CALIPERS_E_DIVIDE_BY_ZERO]
+```
+
+What it means
+- You attempted to divide by zero in a measurement operation.
+
+How to fix
+- Guard inputs before dividing or replace zero with a safe fallback.
+
+### Clamp bounds
+
+Example
+
+```
+css-calipers.Measurement.clamp: clamp: min (20px) must be <= max (12px) [code=CALIPERS_E_CLAMP_INVALID_RANGE]
+```
+
+What it means
+- The clamp minimum is greater than the clamp maximum.
+
+How to fix
+- Ensure min and max come from the same source or swap them before calling clamp.
+
+### Stack hints and configuration
+
+For m and unit helpers, errors include a trimmed stack hint in non-production by default.
+You can disable or force stack hints globally:
+
+```
+import { setErrorConfig } from "css-calipers";
+
+// Disable stack hints everywhere (for production).
+setErrorConfig({ stackHints: "off" });
+
+// Force stack hints everywhere (useful in dev or tests).
+setErrorConfig({ stackHints: "on" });
+```
+
+---
+
+## Factory entrypoint (optional)
+
+If you want instance-scoped configuration and a single re-export surface, use
+the factory entrypoint. The instance includes core helpers, unit helpers, and
+mediaQueries.
+
+```
+import { createCalipers } from "css-calipers/factory";
+
+const calipers = createCalipers({
+  errorConfig: { stackHints: "on" },
+});
+
+export const { m, mPx, mediaQueries, units } = calipers;
+```
+
+See [examples/factory-wrapper.example.ts](examples/factory-wrapper.example.ts)
+for a wrapper module you can re-export across your project.
+
+---
+
 ## Co-existing with other systems
 
 You don’t have to convert everything at once, or at all. If it fits your setup,
@@ -371,3 +469,5 @@ The `examples/` folder contains a few non-published usage sketches:
 - [examples/validation-and-runtime-checks.example.ts](examples/validation-and-runtime-checks.example.ts) &mdash;
   dev-only validation around shared tokens in two different consumers (HTML
   string and style object) using the same line-height measurement.
+- [examples/factory-wrapper.example.ts](examples/factory-wrapper.example.ts) &mdash;
+  instance-scoped factory wrapper that re-exports the helpers.

package/dist/cjs/comparisons/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = void 0;
+exports.compare = {
+    eq: (value) => ({
+        operator: "=",
+        value,
+    }),
+    lt: (value) => ({
+        operator: "<",
+        value,
+    }),
+    lte: (value) => ({
+        operator: "<=",
+        value,
+    }),
+    gt: (value) => ({
+        operator: ">",
+        value,
+    }),
+    gte: (value) => ({
+        operator: ">=",
+        value,
+    }),
+};

package/dist/cjs/containerQueries/containerQueries.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeContainerQueryStyle = exports.buildContainerConditionString = exports.buildContainerQueryString = exports.emitCoreFeatures = exports.createEmitCoreFeatures = void 0;
+const modules_1 = require("./modules");
+const linting_1 = require("./linting");
+const core_1 = require("./linting/core");
+const validation_1 = require("./validation");
+const helpers_1 = require("./helpers");
+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 (!(0, linting_1.runContainerQueryLint)(props, helpers, core_1.lintWidthExactRedundancy, "minWidth should not be combined with maxWidth when both are equal")) {
+        return;
+    }
+    if (!(0, linting_1.runContainerQueryLint)(props, helpers, core_1.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);
+    }
+};
+exports.createEmitCoreFeatures = createEmitCoreFeatures;
+exports.emitCoreFeatures = (0, exports.createEmitCoreFeatures)(validation_1.defaultContainerQueryValidation);
+const emitBaseFeatures = (props, helpers) => {
+    (0, exports.emitCoreFeatures)(props, helpers);
+    (0, modules_1.emitAspectRatioFeatures)(props, helpers);
+    (0, modules_1.emitInlineSizeFeatures)(props, helpers);
+    (0, modules_1.emitBlockSizeFeatures)(props, helpers);
+    (0, modules_1.emitStyleFeatures)(props, helpers);
+    (0, modules_1.emitCustomFeatures)(props, helpers);
+};
+exports.buildContainerQueryString = (0, helpers_1.createContainerQueryBuilder)({
+    emitBase: emitBaseFeatures,
+});
+const wrapContainerCondition = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.includes(" and ") ||
+        trimmed.includes(" or ") ||
+        trimmed.startsWith("not ")) {
+        return `(${trimmed})`;
+    }
+    return trimmed;
+};
+const buildContainerConditionString = (condition) => {
+    if ("and" in condition) {
+        return condition.and
+            .map((entry) => wrapContainerCondition((0, exports.buildContainerConditionString)(entry)))
+            .join(" and ");
+    }
+    if ("or" in condition) {
+        return condition.or
+            .map((entry) => wrapContainerCondition((0, exports.buildContainerConditionString)(entry)))
+            .join(" or ");
+    }
+    if ("not" in condition) {
+        return `not ${wrapContainerCondition((0, exports.buildContainerConditionString)(condition.not))}`;
+    }
+    return (0, exports.buildContainerQueryString)(condition);
+};
+exports.buildContainerConditionString = buildContainerConditionString;
+const makeContainerQueryStyle = (queries) => (stylesByQuery) => {
+    const result = {};
+    Object.keys(stylesByQuery).forEach((key) => {
+        const styles = stylesByQuery[key];
+        const props = queries[key];
+        if (!styles || !props)
+            return;
+        result[(0, exports.buildContainerQueryString)(props)] = styles;
+    });
+    const containerQuery = {
+        "@container": result,
+    };
+    return containerQuery;
+};
+exports.makeContainerQueryStyle = makeContainerQueryStyle;

package/dist/cjs/containerQueries/factory.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerQueryFactory = exports.createContainerQueryFactory = void 0;
+const containerQueries_1 = require("./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);
+};
+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[(0, containerQueries_1.buildContainerConditionString)(rule.query.condition)] = styles;
+        });
+        const containerQuery = {
+            "@container": result,
+        };
+        return options.config.output
+            ? options.config.output(containerQuery)
+            : containerQuery;
+    };
+};
+exports.createContainerQueryFactory = createContainerQueryFactory;
+exports.containerQueryFactory = (0, exports.createContainerQueryFactory)();

package/dist/cjs/containerQueries/helpers.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyContainerQueryValidation = exports.createContainerQueryBuilder = exports.createContainerQueryFeatureEmitterWithTracking = exports.createContainerQueryConditionEmitter = exports.createContainerQueryFeatureEmitter = exports.formatContainerQueryComparison = exports.buildContainerQueryStringFromParts = exports.buildContainerRange = exports.buildContainerComparison = exports.formatContainerQueryValue = void 0;
+const core_1 = require("../core");
+const validation_1 = require("../validation");
+const formatContainerQueryValue = (value) => ((0, core_1.hasCssMethod)(value) ? value.css() : String(value));
+exports.formatContainerQueryValue = formatContainerQueryValue;
+const buildContainerComparison = (comparison) => comparison;
+exports.buildContainerComparison = buildContainerComparison;
+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 };
+};
+exports.buildContainerRange = buildContainerRange;
+const buildContainerQueryStringFromParts = (parts) => parts.join(" and ");
+exports.buildContainerQueryStringFromParts = buildContainerQueryStringFromParts;
+const formatContainerQueryComparison = (name, operator, value) => {
+    return `(${name} ${operator} ${(0, exports.formatContainerQueryValue)(value)})`;
+};
+exports.formatContainerQueryComparison = formatContainerQueryComparison;
+const createContainerQueryFeatureEmitter = (parts) => (name, value) => {
+    parts.push(`(${name}: ${(0, exports.formatContainerQueryValue)(value)})`);
+};
+exports.createContainerQueryFeatureEmitter = createContainerQueryFeatureEmitter;
+const createContainerQueryConditionEmitter = (parts) => (condition) => {
+    parts.push(condition);
+};
+exports.createContainerQueryConditionEmitter = createContainerQueryConditionEmitter;
+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}: ${(0, exports.formatContainerQueryValue)(value)})`);
+    };
+};
+exports.createContainerQueryFeatureEmitterWithTracking = createContainerQueryFeatureEmitterWithTracking;
+const createContainerQueryBuilder = (options) => {
+    return (config) => {
+        var _a, _b, _c, _d, _e;
+        const parts = [];
+        const emittedFeatures = new Set();
+        const helpers = {
+            addFeature: (0, exports.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: (0, exports.createContainerQueryFeatureEmitter)(parts),
+            addCondition: (0, exports.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 (0, exports.buildContainerQueryStringFromParts)(parts);
+    };
+};
+exports.createContainerQueryBuilder = createContainerQueryBuilder;
+const applyContainerQueryValidation = (config, helpers, validator, context) => {
+    var _a, _b;
+    if (!validator)
+        return true;
+    const normalized = (0, validation_1.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}`);
+};
+exports.applyContainerQueryValidation = applyContainerQueryValidation;

package/dist/cjs/containerQueries/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineContainerQueryModules = exports.createContainerQueryFactory = exports.containerQueryFactory = exports.formatContainerQueryValue = exports.buildContainerRange = exports.buildContainerComparison = exports.makeContainerQueryStyle = exports.buildContainerQueryString = exports.buildContainerConditionString = void 0;
+var containerQueries_1 = require("./containerQueries");
+Object.defineProperty(exports, "buildContainerConditionString", { enumerable: true, get: function () { return containerQueries_1.buildContainerConditionString; } });
+Object.defineProperty(exports, "buildContainerQueryString", { enumerable: true, get: function () { return containerQueries_1.buildContainerQueryString; } });
+Object.defineProperty(exports, "makeContainerQueryStyle", { enumerable: true, get: function () { return containerQueries_1.makeContainerQueryStyle; } });
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "buildContainerComparison", { enumerable: true, get: function () { return helpers_1.buildContainerComparison; } });
+Object.defineProperty(exports, "buildContainerRange", { enumerable: true, get: function () { return helpers_1.buildContainerRange; } });
+Object.defineProperty(exports, "formatContainerQueryValue", { enumerable: true, get: function () { return helpers_1.formatContainerQueryValue; } });
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "containerQueryFactory", { enumerable: true, get: function () { return factory_1.containerQueryFactory; } });
+Object.defineProperty(exports, "createContainerQueryFactory", { enumerable: true, get: function () { return factory_1.createContainerQueryFactory; } });
+var moduleRegistry_1 = require("./moduleRegistry");
+Object.defineProperty(exports, "defineContainerQueryModules", { enumerable: true, get: function () { return moduleRegistry_1.defineContainerQueryModules; } });

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintAspectRatioRangeCollapse = exports.lintAspectRatioRedundancy = void 0;
+const ratio_1 = require("../../ratio");
+const lintAspectRatioRedundancy = (props) => {
+    if (!props.aspectRatio)
+        return;
+    if (props.minAspectRatio || props.maxAspectRatio) {
+        throw new Error("aspectRatio should not be combined with minAspectRatio or maxAspectRatio");
+    }
+};
+exports.lintAspectRatioRedundancy = lintAspectRatioRedundancy;
+const lintAspectRatioRangeCollapse = (props) => {
+    if (!props.minAspectRatio || !props.maxAspectRatio)
+        return;
+    if (Array.isArray(props.minAspectRatio) ||
+        Array.isArray(props.maxAspectRatio)) {
+        return;
+    }
+    if ((0, ratio_1.ratioToFloat)(props.minAspectRatio) === (0, ratio_1.ratioToFloat)(props.maxAspectRatio)) {
+        throw new Error("minAspectRatio and maxAspectRatio are equal; use aspectRatio instead");
+    }
+};
+exports.lintAspectRatioRangeCollapse = lintAspectRatioRangeCollapse;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintBlockRangeCollapse = exports.lintBlockRedundancy = void 0;
+const normalizeToArray_1 = require("../../internal/normalizeToArray");
+const lintBlockRedundancy = (props) => {
+    if (!props.blockSize)
+        return;
+    if (props.blockSizeRange) {
+        throw new Error("blockSize should not be combined with blockSizeRange");
+    }
+};
+exports.lintBlockRedundancy = lintBlockRedundancy;
+const lintBlockRangeCollapse = (props) => {
+    if (!props.blockSizeRange)
+        return;
+    (0, normalizeToArray_1.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");
+        }
+    });
+};
+exports.lintBlockRangeCollapse = lintBlockRangeCollapse;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintHeightExactRedundancy = exports.lintWidthExactRedundancy = void 0;
+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");
+    }
+};
+exports.lintWidthExactRedundancy = lintWidthExactRedundancy;
+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");
+    }
+};
+exports.lintHeightExactRedundancy = lintHeightExactRedundancy;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintCustomFeatures = void 0;
+const lintCustomFeatures = (props) => {
+    if (!props.customFeatures)
+        return;
+    if (!Object.keys(props.customFeatures).length) {
+        throw new Error("customFeatures should not be empty.");
+    }
+};
+exports.lintCustomFeatures = lintCustomFeatures;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintInlineRangeCollapse = exports.lintInlineRedundancy = void 0;
+const normalizeToArray_1 = require("../../internal/normalizeToArray");
+const lintInlineRedundancy = (props) => {
+    if (!props.inlineSize)
+        return;
+    if (props.inlineSizeRange) {
+        throw new Error("inlineSize should not be combined with inlineSizeRange");
+    }
+};
+exports.lintInlineRedundancy = lintInlineRedundancy;
+const lintInlineRangeCollapse = (props) => {
+    if (!props.inlineSizeRange)
+        return;
+    (0, normalizeToArray_1.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");
+        }
+    });
+};
+exports.lintInlineRangeCollapse = lintInlineRangeCollapse;

package/dist/cjs/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/cjs/containerQueries/linting/style.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintStyleCondition = void 0;
+const core_1 = require("../../core");
+const isComparisonShape = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return "operator" in value && "value" in value;
+};
+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 ((0, core_1.hasCssMethod)(value))
+            return;
+        if (isComparisonShape(value)) {
+            throw new Error("style conditions must not contain comparisons.");
+        }
+    });
+};
+exports.lintStyleCondition = lintStyleCondition;

package/dist/cjs/containerQueries/linting.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContainerQueryLint = void 0;
+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;
+};
+exports.runContainerQueryLint = runContainerQueryLint;

package/dist/cjs/containerQueries/moduleRegistry.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineContainerQueryModules = void 0;
+const defineContainerQueryModules = (...modules) => modules;
+exports.defineContainerQueryModules = defineContainerQueryModules;