css-calipers 0.7.0 → 0.8.0

package/dist/cjs/mediaQueries/validation.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateResolutionValues = exports.validateAspectRatioValuesPositive = exports.validateMinMaxAspectRatio = exports.validateHeightValuesPositive = exports.validateMinMaxHeight = exports.validateWidthValuesPositive = exports.validateMinMaxWidth = exports.runMediaQueryValidation = void 0;
+const helpers_1 = require("./helpers");
+const core_1 = require("../core");
+const toValidationResult = (error, fallback) => {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return fallback;
+};
+const runMediaQueryValidation = (config, helpers, check, context, fallbackMessage = 'Invalid media query configuration') => {
+    if (!check)
+        return true;
+    try {
+        check(config);
+        return true;
+    }
+    catch (error) {
+        const result = toValidationResult(error, fallbackMessage);
+        return (0, helpers_1.applyMediaQueryValidation)(config, helpers, () => result, context);
+    }
+};
+exports.runMediaQueryValidation = runMediaQueryValidation;
+const validateMinMaxWidth = (props) => {
+    if (!props.minWidth || !props.maxWidth)
+        return;
+    (0, core_1.assertMatchingUnits)(props.minWidth, props.maxWidth, 'mediaQueries.minMaxWidth');
+    (0, core_1.assertCondition)(props.minWidth.getValue() <= props.maxWidth.getValue(), 'minWidth must be less than or equal to maxWidth');
+};
+exports.validateMinMaxWidth = validateMinMaxWidth;
+const validateWidthValuesPositive = (props) => {
+    const assertPositive = (value, label) => {
+        (0, core_1.assertCondition)(value.getValue() > 0, `${label} must be greater than 0`);
+    };
+    if (props.width) {
+        assertPositive(props.width, 'width');
+    }
+    if (props.minWidth) {
+        assertPositive(props.minWidth, 'minWidth');
+    }
+    if (props.maxWidth) {
+        assertPositive(props.maxWidth, 'maxWidth');
+    }
+};
+exports.validateWidthValuesPositive = validateWidthValuesPositive;
+const validateMinMaxHeight = (props) => {
+    if (!props.minHeight || !props.maxHeight)
+        return;
+    (0, core_1.assertMatchingUnits)(props.minHeight, props.maxHeight, 'mediaQueries.minMaxHeight');
+    (0, core_1.assertCondition)(props.minHeight.getValue() <= props.maxHeight.getValue(), 'minHeight must be less than or equal to maxHeight');
+};
+exports.validateMinMaxHeight = validateMinMaxHeight;
+const validateHeightValuesPositive = (props) => {
+    const assertPositive = (value, label) => {
+        (0, core_1.assertCondition)(value.getValue() > 0, `${label} must be greater than 0`);
+    };
+    if (props.height) {
+        assertPositive(props.height, 'height');
+    }
+    if (props.minHeight) {
+        assertPositive(props.minHeight, 'minHeight');
+    }
+    if (props.maxHeight) {
+        assertPositive(props.maxHeight, 'maxHeight');
+    }
+};
+exports.validateHeightValuesPositive = validateHeightValuesPositive;
+const parseAspectRatio = (value) => {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.includes('/')) {
+        const [left, right] = trimmed.split('/');
+        if (left === undefined || right === undefined)
+            return null;
+        const numerator = Number(left.trim());
+        const denominator = Number(right.trim());
+        if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) {
+            return null;
+        }
+        if (denominator === 0)
+            return null;
+        return numerator / denominator;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const validateMinMaxAspectRatio = (props) => {
+    if (!props.minAspectRatio || !props.maxAspectRatio)
+        return;
+    const minRatio = parseAspectRatio(props.minAspectRatio);
+    const maxRatio = parseAspectRatio(props.maxAspectRatio);
+    (0, core_1.assertCondition)(minRatio !== null && maxRatio !== null, 'aspectRatio values must be valid numbers or ratio strings');
+    (0, core_1.assertCondition)(minRatio <= maxRatio, 'minAspectRatio must be less than or equal to maxAspectRatio');
+};
+exports.validateMinMaxAspectRatio = validateMinMaxAspectRatio;
+const validateAspectRatioValuesPositive = (props) => {
+    const assertValidPositive = (label, value) => {
+        (0, core_1.assertCondition)(value !== null && value > 0, `${label} must be a valid ratio greater than 0`);
+    };
+    if (props.aspectRatio !== undefined) {
+        assertValidPositive('aspectRatio', parseAspectRatio(props.aspectRatio));
+    }
+    if (props.minAspectRatio !== undefined) {
+        assertValidPositive('minAspectRatio', parseAspectRatio(props.minAspectRatio));
+    }
+    if (props.maxAspectRatio !== undefined) {
+        assertValidPositive('maxAspectRatio', parseAspectRatio(props.maxAspectRatio));
+    }
+};
+exports.validateAspectRatioValuesPositive = validateAspectRatioValuesPositive;
+const validateResolutionValues = (props) => {
+    const assertPositive = (value, label) => {
+        (0, core_1.assertCondition)(value.getValue() > 0, `${label} must be greater than 0`);
+    };
+    if (props.resolutionValue) {
+        assertPositive(props.resolutionValue, 'resolution');
+    }
+    if (props.minResolution) {
+        assertPositive(props.minResolution, 'minResolution');
+    }
+    if (props.maxResolution) {
+        assertPositive(props.maxResolution, 'maxResolution');
+    }
+    if (props.minResolution && props.maxResolution) {
+        (0, core_1.assertMatchingUnits)(props.minResolution, props.maxResolution, 'mediaQueries.resolutionUnits');
+    }
+};
+exports.validateResolutionValues = validateResolutionValues;

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

@@ -0,0 +1,40 @@
+import type { IMeasurement } from '../core';
+type MediaQueryFeatureValue = string | number | IMeasurement;
+type MediaQueryFeatureEmitter = (name: string, value: MediaQueryFeatureValue) => void;
+export type MediaQueryInvalidValueMode = 'allow' | 'log' | 'throw';
+export type MediaQueryLintingMode = 'allow' | 'log' | 'throw';
+export type MediaQueryBuilderConfig = {
+    errorHandling?: {
+        invalidValueMode?: MediaQueryInvalidValueMode;
+        lintingMode?: MediaQueryLintingMode;
+    };
+};
+export interface MediaQueryBuilderHelpers {
+    addFeature: MediaQueryFeatureEmitter;
+    config: MediaQueryBuilderConfig;
+}
+export type MediaQueryValidationResult = boolean | string | null | undefined | {
+    valid: boolean;
+    message?: string;
+};
+export type MediaQueryValidator<TConfig> = (config: TConfig) => MediaQueryValidationResult;
+export type MediaQueryExtensionHandler<TConfig> = (config: TConfig, helpers: MediaQueryBuilderHelpers) => void;
+type MediaQueryBuilderOptions<TConfig> = {
+    emitBase: MediaQueryExtensionHandler<TConfig>;
+    emitExtensions?: MediaQueryExtensionHandler<TConfig>;
+    resolveType?: (config: TConfig) => 'all' | 'print' | 'screen' | undefined;
+    config?: MediaQueryBuilderConfig;
+};
+export declare const formatMediaQueryValue: (value: MediaQueryFeatureValue) => string;
+export declare const buildMediaQueryStringFromParts: (mediaType: "all" | "print" | "screen", parts: string[]) => string;
+export declare const createMediaQueryFeatureEmitter: (parts: string[]) => MediaQueryFeatureEmitter;
+type MediaQueryFeatureEmitterOptions = {
+    emitted?: Set<string>;
+    lintingMode?: MediaQueryLintingMode;
+};
+export declare const createMediaQueryFeatureEmitterWithTracking: (parts: string[], options?: MediaQueryFeatureEmitterOptions) => MediaQueryFeatureEmitter;
+export declare const createMediaQueryBuilder: <TConfig>(options: MediaQueryBuilderOptions<TConfig>) => (config: TConfig) => string;
+export declare const applyMediaQueryValidation: <TConfig>(config: TConfig, helpers: MediaQueryBuilderHelpers, validator?: MediaQueryValidator<TConfig>, context?: string) => boolean;
+export declare const buildMediaQueryFromFeatures: (features: Record<string, MediaQueryFeatureValue>, mediaType?: "all" | "print" | "screen") => string;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/mediaQueries/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C,KAAK,sBAAsB,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;AAE7D,KAAK,wBAAwB,GAAG,CAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,sBAAsB,KAC1B,IAAI,CAAC;AAEV,MAAM,MAAM,0BAA0B,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;AAE9D,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,CAAC,EAAE;QACd,gBAAgB,CAAC,EAAE,0BAA0B,CAAC;QAC9C,WAAW,CAAC,EAAE,qBAAqB,CAAC;KACrC,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,wBAAwB,CAAC;IACrC,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,MAAM,MAAM,0BAA0B,GAClC,OAAO,GACP,MAAM,GACN,IAAI,GACJ,SAAS,GACT;IACE,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEN,MAAM,MAAM,mBAAmB,CAAC,OAAO,IAAI,CACzC,MAAM,EAAE,OAAO,KACZ,0BAA0B,CAAC;AAEhC,MAAM,MAAM,0BAA0B,CAAC,OAAO,IAAI,CAChD,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,wBAAwB,KAC9B,IAAI,CAAC;AAEV,KAAK,wBAAwB,CAAC,OAAO,IAAI;IACvC,QAAQ,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IAC9C,cAAc,CAAC,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IACrD,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC1E,MAAM,CAAC,EAAE,uBAAuB,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,OAAO,sBAAsB,KAC5B,MAA6D,CAAC;AAEjE,eAAO,MAAM,8BAA8B,GACzC,WAAW,KAAK,GAAG,OAAO,GAAG,QAAQ,EACrC,OAAO,MAAM,EAAE,KACd,MAAgF,CAAC;AAEpF,eAAO,MAAM,8BAA8B,GACzC,OAAO,MAAM,EAAE,KACd,wBAGA,CAAC;AAEJ,KAAK,+BAA+B,GAAG;IACrC,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,0CAA0C,GACrD,OAAO,MAAM,EAAE,EACf,UAAS,+BAAoC,KAC5C,wBAkBF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,EAC7C,SAAS,wBAAwB,CAAC,OAAO,CAAC,MAElC,QAAQ,OAAO,KAAG,MAiB3B,CAAC;AAaF,eAAO,MAAM,yBAAyB,GAAI,OAAO,EAC/C,QAAQ,OAAO,EACf,SAAS,wBAAwB,EACjC,YAAY,mBAAmB,CAAC,OAAO,CAAC,EACxC,UAAU,MAAM,KACf,OAqBF,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,UAAU,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,EAChD,YAAW,KAAK,GAAG,OAAO,GAAG,QAAmB,KAC/C,MAaF,CAAC"}

package/dist/esm/mediaQueries/helpers.js

@@ -0,0 +1,87 @@
+import { hasCssMethod } from '../core';
+export const formatMediaQueryValue = (value) => (hasCssMethod(value) ? value.css() : String(value));
+export const buildMediaQueryStringFromParts = (mediaType, parts) => (parts.length ? `${mediaType} and ${parts.join(' and ')}` : mediaType);
+export const createMediaQueryFeatureEmitter = (parts) => (name, value) => {
+    parts.push(`(${name}: ${formatMediaQueryValue(value)})`);
+};
+export 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}: ${formatMediaQueryValue(value)})`);
+    };
+};
+export const createMediaQueryBuilder = (options) => {
+    return (config) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const parts = [];
+        const emittedFeatures = new Set();
+        const helpers = {
+            addFeature: 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 buildMediaQueryStringFromParts(mediaType, parts);
+    };
+};
+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;
+};
+export 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}`);
+};
+export const buildMediaQueryFromFeatures = (features, mediaType = 'screen') => {
+    const parts = [];
+    const addFeature = createMediaQueryFeatureEmitterWithTracking(parts, {
+        emitted: new Set(),
+        lintingMode: 'throw',
+    });
+    Object.entries(features).forEach(([name, value]) => {
+        if (value === undefined || value === null)
+            return;
+        addFeature(name, value);
+    });
+    return buildMediaQueryStringFromParts(mediaType, parts);
+};

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

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './helpers';
+export * from './mediaQueries';
+export * from './modules';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mediaQueries/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC"}

package/dist/esm/mediaQueries/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './helpers';
+export * from './mediaQueries';
+export * from './modules';

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

@@ -0,0 +1,5 @@
+import type { IMediaQueryCore } from '../mediaQueries';
+import type { IMediaQueryDimensions } from '../modules/dimensions';
+export declare const lintWidthRedundancy: (props: IMediaQueryCore & IMediaQueryDimensions) => void;
+export declare const lintHeightRedundancy: (props: IMediaQueryDimensions) => void;
+//# sourceMappingURL=core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/linting/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,eAAO,MAAM,mBAAmB,GAC9B,OAAO,eAAe,GAAG,qBAAqB,KAC7C,IAOF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,qBAAqB,KAC3B,IAOF,CAAC"}

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

@@ -0,0 +1,14 @@
+export const lintWidthRedundancy = (props) => {
+    if (!props.width)
+        return;
+    if (props.minWidth || props.maxWidth) {
+        throw new Error('width should not be combined with minWidth or maxWidth');
+    }
+};
+export const lintHeightRedundancy = (props) => {
+    if (!props.height)
+        return;
+    if (props.minHeight || props.maxHeight) {
+        throw new Error('height should not be combined with minHeight or maxHeight');
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { IMediaQueryResolutionRange } from '../modules/resolution';
+export declare const lintResolutionRedundancy: (props: IMediaQueryResolutionRange) => void;
+//# sourceMappingURL=resolution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/linting/resolution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE,eAAO,MAAM,wBAAwB,GACnC,OAAO,0BAA0B,KAChC,IAOF,CAAC"}

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

@@ -0,0 +1,7 @@
+export const lintResolutionRedundancy = (props) => {
+    if (!props.resolutionValue)
+        return;
+    if (props.minResolution || props.maxResolution) {
+        throw new Error('resolution should not be combined with minResolution or maxResolution');
+    }
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"linting.d.ts","sourceRoot":"","sources":["../../../src/mediaQueries/linting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EAEzB,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,mBAAmB,CAAC,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;AAErE,eAAO,MAAM,iBAAiB,GAAI,OAAO,EACvC,QAAQ,OAAO,EACf,SAAS,wBAAwB,EACjC,QAAQ,mBAAmB,CAAC,OAAO,CAAC,EACpC,gBAAmC,KAClC,OAiBF,CAAC"}

package/dist/esm/mediaQueries/linting.js

@@ -0,0 +1,20 @@
+export 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;
+};

package/dist/esm/mediaQueries/mediaQueries.d.ts

@@ -0,0 +1,19 @@
+import type { IMeasurement } from "../core";
+import type { ComplexStyleRule, StyleRule } from "./types";
+import { IMediaQueryCustomFeatures, IMediaQueryDimensions, IMediaQueryDisplay, IMediaQueryEnvironment, IMediaQueryInteraction, IMediaQueryPreferences, IMediaQueryResolutionRange } from "./modules";
+export interface IMediaQueryProps extends IMediaQueryCore, IMediaQueryDimensions, IMediaQueryResolutionRange, IMediaQueryInteraction, IMediaQueryPreferences, IMediaQueryDisplay, IMediaQueryEnvironment, IMediaQueryCustomFeatures {
+}
+export interface IMediaQueryCore {
+    type?: "all" | "print" | "screen";
+    minWidth?: IMeasurement;
+    maxWidth?: IMeasurement;
+}
+export interface IMediaQuery {
+    props: IMediaQueryProps;
+    styles: StyleRule;
+}
+export type IMediaQueries = Record<string, IMediaQueryProps>;
+export type IMediaQueryStyles<T extends IMediaQueries> = Partial<Record<keyof T, StyleRule>>;
+export declare const buildMediaQueryString: (config: IMediaQueryProps) => string;
+export declare const makeMediaQueryStyle: <T extends IMediaQueries>(queries: T) => (stylesByQuery: IMediaQueryStyles<T>) => ComplexStyleRule;
+//# sourceMappingURL=mediaQueries.d.ts.map

package/dist/esm/mediaQueries/mediaQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaQueries.d.ts","sourceRoot":"","sources":["../../../src/mediaQueries/mediaQueries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAQ3D,OAAO,EAQL,yBAAyB,EACzB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,gBACf,SAAQ,eAAe,EACrB,qBAAqB,EACrB,0BAA0B,EAC1B,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB;CAAG;AAEhC,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IAClC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,SAAS,CAAC;CACnB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAE7D,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,aAAa,IAAI,OAAO,CAC9D,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,CAC3B,CAAC;AAoDF,eAAO,MAAM,qBAAqB,sCAGhC,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAC7B,CAAC,SAAS,aAAa,EAAE,SAAS,CAAC,MACnC,eAAe,iBAAiB,CAAC,CAAC,CAAC,KAAG,gBActC,CAAC"}

package/dist/esm/mediaQueries/mediaQueries.js

@@ -0,0 +1,46 @@
+import { createMediaQueryBuilder } from "./helpers";
+import { runMediaQueryValidation, validateMinMaxWidth, validateWidthValuesPositive, } from "./validation";
+import { emitCustomFeatures, emitDimensionsFeatures, emitDisplayFeatures, emitEnvironmentFeatures, emitInteractionFeatures, emitPreferencesFeatures, emitResolutionFeatures, } from "./modules";
+const emitCoreFeatures = (props, helpers) => {
+    if (!runMediaQueryValidation(props, helpers, validateMinMaxWidth, "core", "minWidth must be less than or equal to maxWidth")) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, 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);
+    emitDimensionsFeatures(props, helpers);
+    emitResolutionFeatures(props, helpers);
+    emitInteractionFeatures(props, helpers);
+    emitPreferencesFeatures(props, helpers);
+    emitDisplayFeatures(props, helpers);
+    emitEnvironmentFeatures(props, helpers);
+    emitCustomFeatures(props, helpers);
+};
+export const buildMediaQueryString = createMediaQueryBuilder({
+    emitBase: emitBaseFeatures,
+    resolveType: (props) => props.type,
+});
+export const makeMediaQueryStyle = (queries) => (stylesByQuery) => {
+    const result = {};
+    Object.keys(stylesByQuery).forEach((key) => {
+        const styles = stylesByQuery[key];
+        const props = queries[key];
+        if (!styles || !props)
+            return;
+        result[buildMediaQueryString(props)] = styles;
+    });
+    const mediaQuery = {
+        "@media": result,
+    };
+    return mediaQuery;
+};

package/dist/esm/mediaQueries/modules/custom.d.ts

@@ -0,0 +1,10 @@
+import type { IMeasurement } from '../../core';
+import type { MediaQueryBuilderHelpers, MediaQueryValidator } from '../helpers';
+type MediaQueryFeatureValue = string | number | IMeasurement;
+export interface IMediaQueryCustomFeatures {
+    customFeatures?: Record<string, MediaQueryFeatureValue>;
+}
+export type MediaQueryCustomFeaturesValidator = MediaQueryValidator<IMediaQueryCustomFeatures>;
+export declare const emitCustomFeatures: (props: IMediaQueryCustomFeatures, helpers: MediaQueryBuilderHelpers, validate?: MediaQueryCustomFeaturesValidator) => void;
+export {};
+//# sourceMappingURL=custom.d.ts.map

package/dist/esm/mediaQueries/modules/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/modules/custom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAGpB,KAAK,sBAAsB,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;AAE7D,MAAM,WAAW,yBAAyB;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CACzD;AAED,MAAM,MAAM,iCAAiC,GAC3C,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;AAEjD,eAAO,MAAM,kBAAkB,GAC7B,OAAO,yBAAyB,EAChC,SAAS,wBAAwB,EACjC,WAAW,iCAAiC,KAC3C,IAqBF,CAAC"}

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

@@ -0,0 +1,22 @@
+import { hasCssMethod } from '../../core';
+import { applyMediaQueryValidation } from '../helpers';
+export const emitCustomFeatures = (props, helpers, validate) => {
+    if (!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' && !hasCssMethod(value)) {
+            throw new Error(`Custom feature "${trimmedName}" must be a primitive or a measurement.`);
+        }
+        addFeature(trimmedName, value);
+    });
+};

package/dist/esm/mediaQueries/modules/dimensions.d.ts

@@ -0,0 +1,17 @@
+import type { IMeasurement } from '../../core';
+import type { MediaQueryBuilderHelpers, MediaQueryValidator } from '../helpers';
+type MediaQueryRatio = number | string;
+export interface IMediaQueryDimensions {
+    width?: IMeasurement;
+    minHeight?: IMeasurement;
+    maxHeight?: IMeasurement;
+    height?: IMeasurement;
+    aspectRatio?: MediaQueryRatio;
+    minAspectRatio?: MediaQueryRatio;
+    maxAspectRatio?: MediaQueryRatio;
+    orientation?: 'landscape' | 'portrait';
+}
+export type MediaQueryDimensionsValidator = MediaQueryValidator<IMediaQueryDimensions>;
+export declare const emitDimensionsFeatures: (props: IMediaQueryDimensions, helpers: MediaQueryBuilderHelpers, validate?: MediaQueryDimensionsValidator) => void;
+export {};
+//# sourceMappingURL=dimensions.d.ts.map

package/dist/esm/mediaQueries/modules/dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/modules/dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAgBpB,KAAK,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvC,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC,WAAW,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;CACxC;AAED,MAAM,MAAM,6BAA6B,GACvC,mBAAmB,CAAC,qBAAqB,CAAC,CAAC;AAE7C,eAAO,MAAM,sBAAsB,GACjC,OAAO,qBAAqB,EAC5B,SAAS,wBAAwB,EACjC,WAAW,6BAA6B,KACvC,IA0GF,CAAC"}

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

@@ -0,0 +1,55 @@
+import { applyMediaQueryValidation } from '../helpers';
+import { runMediaQueryValidation, validateAspectRatioValuesPositive, validateHeightValuesPositive, validateMinMaxAspectRatio, validateMinMaxHeight, validateWidthValuesPositive, } from '../validation';
+import { runMediaQueryLint } from '../linting';
+import { lintHeightRedundancy, lintWidthRedundancy, } from '../linting/core';
+export const emitDimensionsFeatures = (props, helpers, validate) => {
+    if (!runMediaQueryValidation(props, helpers, validateMinMaxHeight, 'dimensions', 'minHeight must be less than or equal to maxHeight')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateHeightValuesPositive, 'dimensions', 'height values must be greater than 0')) {
+        return;
+    }
+    if (!runMediaQueryLint(props, helpers, lintWidthRedundancy, 'width should not be combined with minWidth or maxWidth')) {
+        return;
+    }
+    if (!runMediaQueryLint(props, helpers, lintHeightRedundancy, 'height should not be combined with minHeight or maxHeight')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateWidthValuesPositive, 'dimensions', 'width values must be greater than 0')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateMinMaxAspectRatio, 'dimensions', 'minAspectRatio must be less than or equal to maxAspectRatio')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateAspectRatioValuesPositive, 'dimensions', 'aspect ratio values must be greater than 0')) {
+        return;
+    }
+    if (!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);
+    }
+};

package/dist/esm/mediaQueries/modules/display.d.ts

@@ -0,0 +1,9 @@
+import type { MediaQueryBuilderHelpers, MediaQueryValidator } from '../helpers';
+export interface IMediaQueryDisplay {
+    colorGamut?: 'srgb' | 'p3' | 'rec2020';
+    dynamicRange?: 'standard' | 'high';
+    invertedColors?: 'none' | 'inverted';
+}
+export type MediaQueryDisplayValidator = MediaQueryValidator<IMediaQueryDisplay>;
+export declare const emitDisplayFeatures: (props: IMediaQueryDisplay, helpers: MediaQueryBuilderHelpers, validate?: MediaQueryDisplayValidator) => void;
+//# sourceMappingURL=display.d.ts.map

package/dist/esm/mediaQueries/modules/display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/modules/display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACvC,YAAY,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;CACtC;AAED,MAAM,MAAM,0BAA0B,GACpC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;AAE1C,eAAO,MAAM,mBAAmB,GAC9B,OAAO,kBAAkB,EACzB,SAAS,wBAAwB,EACjC,WAAW,0BAA0B,KACpC,IAgBF,CAAC"}

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

@@ -0,0 +1,16 @@
+import { applyMediaQueryValidation } from '../helpers';
+export const emitDisplayFeatures = (props, helpers, validate) => {
+    if (!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);
+    }
+};

package/dist/esm/mediaQueries/modules/environment.d.ts

@@ -0,0 +1,9 @@
+import type { MediaQueryBuilderHelpers, MediaQueryValidator } from '../helpers';
+export interface IMediaQueryEnvironment {
+    scripting?: 'none' | 'initial-only' | 'enabled';
+    overflowBlock?: 'none' | 'scroll' | 'paged';
+    overflowInline?: 'none' | 'scroll';
+}
+export type MediaQueryEnvironmentValidator = MediaQueryValidator<IMediaQueryEnvironment>;
+export declare const emitEnvironmentFeatures: (props: IMediaQueryEnvironment, helpers: MediaQueryBuilderHelpers, validate?: MediaQueryEnvironmentValidator) => void;
+//# sourceMappingURL=environment.d.ts.map

package/dist/esm/mediaQueries/modules/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/modules/environment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAChD,aAAa,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC5C,cAAc,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;CACpC;AAED,MAAM,MAAM,8BAA8B,GACxC,mBAAmB,CAAC,sBAAsB,CAAC,CAAC;AAE9C,eAAO,MAAM,uBAAuB,GAClC,OAAO,sBAAsB,EAC7B,SAAS,wBAAwB,EACjC,WAAW,8BAA8B,KACxC,IAkBF,CAAC"}

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

@@ -0,0 +1,16 @@
+import { applyMediaQueryValidation } from '../helpers';
+export const emitEnvironmentFeatures = (props, helpers, validate) => {
+    if (!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);
+    }
+};

package/dist/esm/mediaQueries/modules/index.d.ts

@@ -0,0 +1,8 @@
+export * from './custom';
+export * from './dimensions';
+export * from './display';
+export * from './environment';
+export * from './interaction';
+export * from './preferences';
+export * from './resolution';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/mediaQueries/modules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mediaQueries/modules/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

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

@@ -0,0 +1,7 @@
+export * from './custom';
+export * from './dimensions';
+export * from './display';
+export * from './environment';
+export * from './interaction';
+export * from './preferences';
+export * from './resolution';