css-calipers 0.7.0 → 0.8.0

package/README.md

@@ -7,6 +7,13 @@ CSS-Calipers is a tiny layer for typed CSS measurements. Stop parsing CSS
 strings and concatenating units. Do your math on real numbers, get
 compile-time unit safety, and output CSS only at the edges.
 
+This README is a general overview. Deeper module guides live in their own files.
+
+Module guides:
+
+- Measurements core: README_MEASUREMENT.md
+- Media queries: README_MEDIAQUERIES.md
+
 At a glance:
 
 - Create measurements with `m` from a number and a unit; if you omit the unit, it defaults to `px` and is typed as the px measurement type.

package/dist/cjs/mediaQueries/helpers.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMediaQueryFromFeatures = exports.applyMediaQueryValidation = exports.createMediaQueryBuilder = exports.createMediaQueryFeatureEmitterWithTracking = exports.createMediaQueryFeatureEmitter = exports.buildMediaQueryStringFromParts = exports.formatMediaQueryValue = void 0;
+const core_1 = require("../core");
+const formatMediaQueryValue = (value) => ((0, core_1.hasCssMethod)(value) ? value.css() : String(value));
+exports.formatMediaQueryValue = formatMediaQueryValue;
+const buildMediaQueryStringFromParts = (mediaType, parts) => (parts.length ? `${mediaType} and ${parts.join(' and ')}` : mediaType);
+exports.buildMediaQueryStringFromParts = buildMediaQueryStringFromParts;
+const createMediaQueryFeatureEmitter = (parts) => (name, value) => {
+    parts.push(`(${name}: ${(0, exports.formatMediaQueryValue)(value)})`);
+};
+exports.createMediaQueryFeatureEmitter = createMediaQueryFeatureEmitter;
+const createMediaQueryFeatureEmitterWithTracking = (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(`Media query feature "${name}" was emitted more than once.`);
+            }
+            if (lintingMode === 'log') {
+                console.warn(`Media 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.formatMediaQueryValue)(value)})`);
+    };
+};
+exports.createMediaQueryFeatureEmitterWithTracking = createMediaQueryFeatureEmitterWithTracking;
+const createMediaQueryBuilder = (options) => {
+    return (config) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const parts = [];
+        const emittedFeatures = new Set();
+        const helpers = {
+            addFeature: (0, exports.createMediaQueryFeatureEmitterWithTracking)(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',
+            }),
+            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);
+        const mediaType = (_g = (_f = options.resolveType) === null || _f === void 0 ? void 0 : _f.call(options, config)) !== null && _g !== void 0 ? _g : 'screen';
+        return (0, exports.buildMediaQueryStringFromParts)(mediaType, parts);
+    };
+};
+exports.createMediaQueryBuilder = createMediaQueryBuilder;
+const normalizeValidationResult = (result) => {
+    if (result === undefined || result === null)
+        return { valid: true };
+    if (typeof result === 'boolean')
+        return { valid: result };
+    if (typeof result === 'string') {
+        return result ? { valid: false, message: result } : { valid: true };
+    }
+    return result;
+};
+const applyMediaQueryValidation = (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
+            ? `Media query ${context} validation failed`
+            : 'Media 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
+        ? `Media query ${context} validation failed`
+        : 'Media query validation failed';
+    throw new Error(`${prefix}${suffix}`);
+};
+exports.applyMediaQueryValidation = applyMediaQueryValidation;
+const buildMediaQueryFromFeatures = (features, mediaType = 'screen') => {
+    const parts = [];
+    const addFeature = (0, exports.createMediaQueryFeatureEmitterWithTracking)(parts, {
+        emitted: new Set(),
+        lintingMode: 'throw',
+    });
+    Object.entries(features).forEach(([name, value]) => {
+        if (value === undefined || value === null)
+            return;
+        addFeature(name, value);
+    });
+    return (0, exports.buildMediaQueryStringFromParts)(mediaType, parts);
+};
+exports.buildMediaQueryFromFeatures = buildMediaQueryFromFeatures;

package/dist/cjs/mediaQueries/index.js

@@ -0,0 +1,20 @@
+"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("./types"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./mediaQueries"), exports);
+__exportStar(require("./modules"), exports);

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintHeightRedundancy = exports.lintWidthRedundancy = void 0;
+const lintWidthRedundancy = (props) => {
+    if (!props.width)
+        return;
+    if (props.minWidth || props.maxWidth) {
+        throw new Error('width should not be combined with minWidth or maxWidth');
+    }
+};
+exports.lintWidthRedundancy = lintWidthRedundancy;
+const lintHeightRedundancy = (props) => {
+    if (!props.height)
+        return;
+    if (props.minHeight || props.maxHeight) {
+        throw new Error('height should not be combined with minHeight or maxHeight');
+    }
+};
+exports.lintHeightRedundancy = lintHeightRedundancy;

package/dist/cjs/mediaQueries/linting/resolution.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintResolutionRedundancy = void 0;
+const lintResolutionRedundancy = (props) => {
+    if (!props.resolutionValue)
+        return;
+    if (props.minResolution || props.maxResolution) {
+        throw new Error('resolution should not be combined with minResolution or maxResolution');
+    }
+};
+exports.lintResolutionRedundancy = lintResolutionRedundancy;

package/dist/cjs/mediaQueries/linting.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMediaQueryLint = void 0;
+const runMediaQueryLint = (config, helpers, check, message = 'Media 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 : 'allow';
+    if (mode === 'allow')
+        return true;
+    if (mode === 'log') {
+        try {
+            check(config);
+            return true;
+        }
+        catch {
+            console.warn(message);
+            return true;
+        }
+    }
+    check(config);
+    return true;
+};
+exports.runMediaQueryLint = runMediaQueryLint;

package/dist/cjs/mediaQueries/mediaQueries.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMediaQueryStyle = exports.buildMediaQueryString = void 0;
+const helpers_1 = require("./helpers");
+const validation_1 = require("./validation");
+const modules_1 = require("./modules");
+const emitCoreFeatures = (props, helpers) => {
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateMinMaxWidth, "core", "minWidth must be less than or equal to maxWidth")) {
+        return;
+    }
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateWidthValuesPositive, "core", "width values must be greater than 0")) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.minWidth) {
+        addFeature("min-width", props.minWidth);
+    }
+    if (props.maxWidth) {
+        addFeature("max-width", props.maxWidth);
+    }
+};
+const emitBaseFeatures = (props, helpers) => {
+    emitCoreFeatures(props, helpers);
+    (0, modules_1.emitDimensionsFeatures)(props, helpers);
+    (0, modules_1.emitResolutionFeatures)(props, helpers);
+    (0, modules_1.emitInteractionFeatures)(props, helpers);
+    (0, modules_1.emitPreferencesFeatures)(props, helpers);
+    (0, modules_1.emitDisplayFeatures)(props, helpers);
+    (0, modules_1.emitEnvironmentFeatures)(props, helpers);
+    (0, modules_1.emitCustomFeatures)(props, helpers);
+};
+exports.buildMediaQueryString = (0, helpers_1.createMediaQueryBuilder)({
+    emitBase: emitBaseFeatures,
+    resolveType: (props) => props.type,
+});
+const makeMediaQueryStyle = (queries) => (stylesByQuery) => {
+    const result = {};
+    Object.keys(stylesByQuery).forEach((key) => {
+        const styles = stylesByQuery[key];
+        const props = queries[key];
+        if (!styles || !props)
+            return;
+        result[(0, exports.buildMediaQueryString)(props)] = styles;
+    });
+    const mediaQuery = {
+        "@media": result,
+    };
+    return mediaQuery;
+};
+exports.makeMediaQueryStyle = makeMediaQueryStyle;

package/dist/cjs/mediaQueries/mediaQueryFactory.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queriesToStrings = queriesToStrings;
+exports.useMediaQuery = useMediaQuery;
+exports.useMediaFromMap = useMediaFromMap;
+exports.makeClientFns = makeClientFns;
+const react_1 = require("react");
+const mediaQueries_1 = require("./mediaQueries");
+function toQueryString(q) {
+    return (0, mediaQueries_1.buildMediaQueryString)(q);
+}
+function queriesToStrings(queries) {
+    return Object.fromEntries(Object.entries(queries).map(([k, v,]) => [
+        k,
+        typeof v === 'string' ? v : toQueryString(v),
+    ]));
+}
+// ---------- Core hooks ----------
+/**
+ * SSR-safe: undefined on server, boolean on client; subscribes to
+ * changes.
+ */
+function useMediaQuery(queryString) {
+    const [matches, setMatches,] = (0, react_1.useState)(undefined);
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (typeof window === 'undefined')
+            return;
+        const mql = window.matchMedia(queryString);
+        const onChange = () => setMatches(mql.matches);
+        const frameId = requestAnimationFrame(() => {
+            setMatches(mql.matches);
+        });
+        (_a = mql.addEventListener) === null || _a === void 0 ? void 0 : _a.call(mql, 'change', onChange);
+        return () => {
+            var _a;
+            (_a = mql.removeEventListener) === null || _a === void 0 ? void 0 : _a.call(mql, 'change', onChange);
+            cancelAnimationFrame(frameId);
+        };
+    }, [
+        queryString,
+    ]);
+    return matches;
+}
+// Aggregate hook with guarded updates to avoid loops
+function useMediaFromMap(strings) {
+    const shallowEqual = (0, react_1.useCallback)((a, b) => {
+        const ak = Object.keys(a);
+        const bk = Object.keys(b);
+        if (ak.length !== bk.length)
+            return false;
+        for (const k of ak)
+            if (a[k] !== b[k])
+                return false;
+        return true;
+    }, []);
+    // Stable, sorted list of [key, queryString]
+    const entries = (0, react_1.useMemo)(() => {
+        const e = Object.entries(strings);
+        e.sort((a, b) => a[0].localeCompare(b[0]));
+        return e;
+    }, [
+        strings,
+    ]);
+    const [matches, setMatches,] = (0, react_1.useState)(() => Object.create(null));
+    (0, react_1.useEffect)(() => {
+        if (typeof window === 'undefined')
+            return;
+        const mqls = entries.map(([k, qs,]) => [
+            k,
+            window.matchMedia(qs),
+        ]);
+        // Initial snapshot — only set if changed
+        const initial = Object.fromEntries(mqls.map(([k, mql,]) => [
+            k,
+            mql.matches,
+        ]));
+        const frameId = requestAnimationFrame(() => {
+            setMatches((prev) => shallowEqual(prev, initial) ? prev : initial);
+        });
+        // Subscribe with guarded setState
+        const handlers = mqls.map(([k, mql,]) => {
+            var _a;
+            const onChange = () => setMatches((prev) => {
+                const next = {
+                    ...prev,
+                    [k]: mql.matches,
+                };
+                return shallowEqual(prev, next) ? prev : next;
+            });
+            (_a = mql.addEventListener) === null || _a === void 0 ? void 0 : _a.call(mql, 'change', onChange);
+            return [
+                mql,
+                onChange,
+            ];
+        });
+        return () => {
+            var _a;
+            cancelAnimationFrame(frameId);
+            for (const [mql, onChange,] of handlers) {
+                (_a = mql.removeEventListener) === null || _a === void 0 ? void 0 : _a.call(mql, 'change', onChange);
+            }
+        };
+    }, [
+        entries,
+        shallowEqual,
+    ]);
+    return matches;
+}
+// ---------- Client-only predicates ----------
+/** For event handlers/effects only; don't call in SSR render paths. */
+function makeClientFns(strings) {
+    const out = {};
+    Object.keys(strings).forEach((k) => {
+        out[k] = () => typeof window !== 'undefined'
+            ? window.matchMedia(strings[k]).matches
+            : false;
+    });
+    return out;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitCustomFeatures = void 0;
+const core_1 = require("../../core");
+const helpers_1 = require("../helpers");
+const emitCustomFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'custom')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (!props.customFeatures)
+        return;
+    Object.entries(props.customFeatures).forEach(([name, value]) => {
+        if (value === undefined || value === null)
+            return;
+        const trimmedName = name.trim();
+        if (!trimmedName) {
+            throw new Error('Custom feature name must be non-empty.');
+        }
+        if (typeof value === 'object' && !(0, core_1.hasCssMethod)(value)) {
+            throw new Error(`Custom feature "${trimmedName}" must be a primitive or a measurement.`);
+        }
+        addFeature(trimmedName, value);
+    });
+};
+exports.emitCustomFeatures = emitCustomFeatures;

package/dist/cjs/mediaQueries/modules/dimensions.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitDimensionsFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const core_1 = require("../linting/core");
+const emitDimensionsFeatures = (props, helpers, validate) => {
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateMinMaxHeight, 'dimensions', 'minHeight must be less than or equal to maxHeight')) {
+        return;
+    }
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateHeightValuesPositive, 'dimensions', 'height values must be greater than 0')) {
+        return;
+    }
+    if (!(0, linting_1.runMediaQueryLint)(props, helpers, core_1.lintWidthRedundancy, 'width should not be combined with minWidth or maxWidth')) {
+        return;
+    }
+    if (!(0, linting_1.runMediaQueryLint)(props, helpers, core_1.lintHeightRedundancy, 'height should not be combined with minHeight or maxHeight')) {
+        return;
+    }
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateWidthValuesPositive, 'dimensions', 'width values must be greater than 0')) {
+        return;
+    }
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateMinMaxAspectRatio, 'dimensions', 'minAspectRatio must be less than or equal to maxAspectRatio')) {
+        return;
+    }
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateAspectRatioValuesPositive, 'dimensions', 'aspect ratio values must be greater than 0')) {
+        return;
+    }
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'dimensions')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.width) {
+        addFeature('width', props.width);
+    }
+    if (props.height) {
+        addFeature('height', props.height);
+    }
+    if (props.minHeight) {
+        addFeature('min-height', props.minHeight);
+    }
+    if (props.maxHeight) {
+        addFeature('max-height', props.maxHeight);
+    }
+    if (props.aspectRatio) {
+        addFeature('aspect-ratio', props.aspectRatio);
+    }
+    if (props.minAspectRatio) {
+        addFeature('min-aspect-ratio', props.minAspectRatio);
+    }
+    if (props.maxAspectRatio) {
+        addFeature('max-aspect-ratio', props.maxAspectRatio);
+    }
+    if (props.orientation) {
+        addFeature('orientation', props.orientation);
+    }
+};
+exports.emitDimensionsFeatures = emitDimensionsFeatures;

package/dist/cjs/mediaQueries/modules/display.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitDisplayFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitDisplayFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'display')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.colorGamut) {
+        addFeature('color-gamut', props.colorGamut);
+    }
+    if (props.dynamicRange) {
+        addFeature('dynamic-range', props.dynamicRange);
+    }
+    if (props.invertedColors) {
+        addFeature('inverted-colors', props.invertedColors);
+    }
+};
+exports.emitDisplayFeatures = emitDisplayFeatures;

package/dist/cjs/mediaQueries/modules/environment.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitEnvironmentFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitEnvironmentFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'environment')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.scripting) {
+        addFeature('scripting', props.scripting);
+    }
+    if (props.overflowBlock) {
+        addFeature('overflow-block', props.overflowBlock);
+    }
+    if (props.overflowInline) {
+        addFeature('overflow-inline', props.overflowInline);
+    }
+};
+exports.emitEnvironmentFeatures = emitEnvironmentFeatures;

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

@@ -0,0 +1,23 @@
+"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("./custom"), exports);
+__exportStar(require("./dimensions"), exports);
+__exportStar(require("./display"), exports);
+__exportStar(require("./environment"), exports);
+__exportStar(require("./interaction"), exports);
+__exportStar(require("./preferences"), exports);
+__exportStar(require("./resolution"), exports);

package/dist/cjs/mediaQueries/modules/interaction.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitInteractionFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitInteractionFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'interaction')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.hover) {
+        addFeature('hover', props.hover);
+    }
+    if (props.anyHover) {
+        addFeature('any-hover', props.anyHover);
+    }
+    if (props.pointer) {
+        addFeature('pointer', props.pointer);
+    }
+    if (props.anyPointer) {
+        addFeature('any-pointer', props.anyPointer);
+    }
+    if (props.update) {
+        addFeature('update', props.update);
+    }
+};
+exports.emitInteractionFeatures = emitInteractionFeatures;

package/dist/cjs/mediaQueries/modules/preferences.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPreferencesFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitPreferencesFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'preferences')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.colorScheme) {
+        addFeature('prefers-color-scheme', props.colorScheme);
+    }
+    if (props.reducedMotion) {
+        addFeature('prefers-reduced-motion', props.reducedMotion);
+    }
+    if (props.reducedData) {
+        addFeature('prefers-reduced-data', props.reducedData);
+    }
+    if (props.contrast) {
+        addFeature('prefers-contrast', props.contrast);
+    }
+    if (props.forcedColors) {
+        addFeature('forced-colors', props.forcedColors);
+    }
+};
+exports.emitPreferencesFeatures = emitPreferencesFeatures;

package/dist/cjs/mediaQueries/modules/resolution.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitResolutionFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const resolution_1 = require("../linting/resolution");
+const emitResolutionFeatures = (props, helpers, validate) => {
+    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateResolutionValues, 'resolution', 'resolution values must be greater than 0')) {
+        return;
+    }
+    if (!(0, linting_1.runMediaQueryLint)(props, helpers, resolution_1.lintResolutionRedundancy, 'resolution should not be combined with minResolution or maxResolution')) {
+        return;
+    }
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'resolution')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.resolutionValue) {
+        addFeature('resolution', props.resolutionValue);
+    }
+    if (props.minResolution) {
+        addFeature('min-resolution', props.minResolution);
+    }
+    if (props.maxResolution) {
+        addFeature('max-resolution', props.maxResolution);
+    }
+};
+exports.emitResolutionFeatures = emitResolutionFeatures;

package/dist/cjs/mediaQueries/types.js

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