css-calipers 0.9.3 → 0.9.4

package/dist/examples/src/internal/createMediaQueriesApi.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMediaQueriesApi = void 0;
+const helpers_1 = require("../mediaQueries/helpers");
+const validation_1 = require("../mediaQueries/validation");
+const mediaQueries_1 = require("../mediaQueries/mediaQueries");
+const modules_1 = require("../mediaQueries/modules");
+const resolution_1 = require("../mediaQueries/modules/resolution");
+const factory_1 = require("../mediaQueries/factory");
+const vanilla_extract_1 = require("../libraryHelpers/vanilla-extract");
+const createMediaQueriesApi = (core) => {
+    const validation = (0, validation_1.createMediaQueryValidation)({
+        assertCondition: core.assertCondition,
+        assertMatchingUnits: core.assertMatchingUnits,
+    });
+    const emitCoreFeatures = (0, mediaQueries_1.createEmitCoreFeatures)(validation);
+    const emitDimensionsFeatures = (0, modules_1.createEmitDimensionsFeatures)(validation);
+    const emitResolutionFeatures = (0, resolution_1.createEmitResolutionFeatures)(validation);
+    const emitBaseFeatures = (props, helpers) => {
+        emitCoreFeatures(props, helpers);
+        emitDimensionsFeatures(props, helpers);
+        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);
+    };
+    const 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[buildMediaQueryString(props)] = styles;
+        });
+        const mediaQuery = {
+            "@media": result,
+        };
+        return mediaQuery;
+    };
+    const moduleEmitters = {
+        core: emitCoreFeatures,
+        dimensions: emitDimensionsFeatures,
+        resolution: emitResolutionFeatures,
+        interaction: modules_1.emitInteractionFeatures,
+        preferences: modules_1.emitPreferencesFeatures,
+        display: modules_1.emitDisplayFeatures,
+        environment: modules_1.emitEnvironmentFeatures,
+        custom: modules_1.emitCustomFeatures,
+    };
+    const mediaQueryFactory = (0, factory_1.createMediaQueryFactory)(moduleEmitters);
+    return {
+        buildMediaQueryString,
+        makeMediaQueryStyle,
+        mediaQueryFactory,
+        emitCoreFeatures,
+        emitDimensionsFeatures,
+        emitResolutionFeatures,
+        emitInteractionFeatures: modules_1.emitInteractionFeatures,
+        emitPreferencesFeatures: modules_1.emitPreferencesFeatures,
+        emitDisplayFeatures: modules_1.emitDisplayFeatures,
+        emitEnvironmentFeatures: modules_1.emitEnvironmentFeatures,
+        emitCustomFeatures: modules_1.emitCustomFeatures,
+        mediaQueryOutputVanillaExtract: vanilla_extract_1.mediaQueryOutputVanillaExtract,
+        createMediaQueryBuilder: helpers_1.createMediaQueryBuilder,
+    };
+};
+exports.createMediaQueriesApi = createMediaQueriesApi;

package/dist/examples/src/internal/createUnitsApi.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnitsApi = void 0;
+const unitDefinitions_1 = require("../unitDefinitions");
+const createUnitsApi = (core) => {
+    const helpers = Object.keys(unitDefinitions_1.UNIT_DEFINITIONS).reduce((acc, name) => {
+        const helperName = name;
+        acc[helperName] = core.makeUnitHelperFromDefinition(helperName);
+        return acc;
+    }, {});
+    const mPercent = helpers.mPercent;
+    return {
+        ...helpers,
+        isPercentMeasurement: core.makeUnitGuard(mPercent),
+        assertPercentMeasurement: core.makeUnitAssert(mPercent),
+    };
+};
+exports.createUnitsApi = createUnitsApi;

package/dist/examples/src/internal/errors.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwHelperError = exports.throwMeasurementMethodError = exports.createErrorHelpers = exports.getErrorConfig = exports.setErrorConfig = exports.createErrorConfigStore = void 0;
+const DEFAULT_ERROR_CONFIG = {
+    stackHints: "auto",
+};
+let errorConfig = { ...DEFAULT_ERROR_CONFIG };
+const createErrorConfigStore = (initial = {}) => {
+    let config = {
+        ...DEFAULT_ERROR_CONFIG,
+        ...initial,
+    };
+    return {
+        getErrorConfig: () => config,
+        setErrorConfig: (next) => {
+            config = { ...config, ...next };
+        },
+    };
+};
+exports.createErrorConfigStore = createErrorConfigStore;
+const setErrorConfig = (next) => {
+    errorConfig = { ...errorConfig, ...next };
+};
+exports.setErrorConfig = setErrorConfig;
+const getErrorConfig = () => errorConfig;
+exports.getErrorConfig = getErrorConfig;
+const createErrorHelpers = (store) => {
+    const getConfig = () => store.getErrorConfig();
+    const throwMeasurementMethodError = (ctx) => {
+        const includeStack = shouldIncludeStackHint(ctx.includeStackHint, getConfig());
+        const stackHint = includeStack
+            ? extractStackHint(new Error().stack)
+            : undefined;
+        throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+            ...ctx.details,
+            stackHint,
+        }));
+    };
+    const throwHelperError = (ctx) => {
+        const includeStack = shouldIncludeStackHint(ctx.includeStackHint, getConfig());
+        const stackHint = includeStack
+            ? extractStackHint(new Error().stack)
+            : undefined;
+        throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+            ...ctx.details,
+            stackHint,
+        }));
+    };
+    return { throwMeasurementMethodError, throwHelperError };
+};
+exports.createErrorHelpers = createErrorHelpers;
+const isProductionEnv = () => {
+    var _a;
+    if (typeof globalThis === "undefined")
+        return false;
+    const maybeProcess = globalThis
+        .process;
+    return ((_a = maybeProcess === null || maybeProcess === void 0 ? void 0 : maybeProcess.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) === "production";
+};
+const shouldIncludeStackHint = (override, config = errorConfig) => {
+    if (override === false)
+        return false;
+    if (config.stackHints === "off")
+        return false;
+    if (config.stackHints === "on")
+        return true;
+    if (override === true)
+        return !isProductionEnv();
+    return false;
+};
+const formatDetailBlock = (details) => {
+    if (!details)
+        return "";
+    const parts = [];
+    if (details.code)
+        parts.push(`code=${details.code}`);
+    if (details.helper)
+        parts.push(`helper=${details.helper}`);
+    if (details.inputSummary)
+        parts.push(`inputs=${details.inputSummary}`);
+    if (details.stackHint)
+        parts.push(`stack=${details.stackHint}`);
+    return parts.length > 0 ? ` [${parts.join(" | ")}]` : "";
+};
+const formatErrorMessage = (operation, message, context, details) => {
+    const core = `${operation}: ${message}`;
+    const base = context ? `${context}: ${core}` : core;
+    return `${base}${formatDetailBlock(details)}`;
+};
+const extractStackHint = (stack) => {
+    var _a;
+    if (!stack)
+        return undefined;
+    const lines = stack
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(1);
+    if (lines.length === 0)
+        return undefined;
+    const filtered = lines.filter((line) => !line.includes("/src/internal/errors") &&
+        !line.includes("throwHelperError") &&
+        !line.includes("throwMeasurementMethodError"));
+    const hint = (_a = filtered[0]) !== null && _a !== void 0 ? _a : lines[0];
+    return hint.replace(/^at\s+/, "");
+};
+/** Throw an Error for a Measurement instance method using a structured context. */
+const throwMeasurementMethodError = (ctx) => {
+    const includeStack = shouldIncludeStackHint(ctx.includeStackHint);
+    const stackHint = includeStack
+        ? extractStackHint(new Error().stack)
+        : undefined;
+    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+        ...ctx.details,
+        stackHint,
+    }));
+};
+exports.throwMeasurementMethodError = throwMeasurementMethodError;
+/** Throw an Error for a helper/free function using a structured context. */
+const throwHelperError = (ctx) => {
+    const includeStack = shouldIncludeStackHint(ctx.includeStackHint);
+    const stackHint = includeStack
+        ? extractStackHint(new Error().stack)
+        : undefined;
+    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+        ...ctx.details,
+        stackHint,
+    }));
+};
+exports.throwHelperError = throwHelperError;

package/dist/examples/src/libraryHelpers/vanilla-extract.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerQueryOutputVanillaExtract = exports.mediaQueryOutputVanillaExtract = void 0;
+const mediaQueryOutputVanillaExtract = (media) => ({
+    "&": media,
+});
+exports.mediaQueryOutputVanillaExtract = mediaQueryOutputVanillaExtract;
+const containerQueryOutputVanillaExtract = (container) => ({
+    "&": container,
+});
+exports.containerQueryOutputVanillaExtract = containerQueryOutputVanillaExtract;

package/dist/examples/src/mediaQueries/factory.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaQueryFactory = exports.createMediaQueryFactory = void 0;
+const helpers_1 = require("./helpers");
+const mediaQueries_1 = require("./mediaQueries");
+const modules_1 = require("./modules");
+const ALL_MEDIA_QUERY_MODULES = [
+    'core',
+    'dimensions',
+    'resolution',
+    'interaction',
+    'preferences',
+    'display',
+    'environment',
+    'custom',
+];
+const MODULE_KEYS = {
+    core: ['type', 'minWidth', 'maxWidth'],
+    dimensions: [
+        'width',
+        'height',
+        'minHeight',
+        'maxHeight',
+        'aspectRatio',
+        'minAspectRatio',
+        'maxAspectRatio',
+        'orientation',
+    ],
+    resolution: ['resolutionValue', 'minResolution', 'maxResolution'],
+    interaction: ['hover', 'anyHover', 'pointer', 'anyPointer', 'update'],
+    preferences: [
+        'colorScheme',
+        'reducedMotion',
+        'reducedData',
+        'contrast',
+        'forcedColors',
+    ],
+    display: ['colorGamut', 'dynamicRange', 'invertedColors'],
+    environment: ['scripting', 'overflowBlock', 'overflowInline'],
+    custom: ['customFeatures'],
+};
+const MODULE_EMITTERS = {
+    core: mediaQueries_1.emitCoreFeatures,
+    dimensions: modules_1.emitDimensionsFeatures,
+    resolution: modules_1.emitResolutionFeatures,
+    interaction: modules_1.emitInteractionFeatures,
+    preferences: modules_1.emitPreferencesFeatures,
+    display: modules_1.emitDisplayFeatures,
+    environment: modules_1.emitEnvironmentFeatures,
+    custom: modules_1.emitCustomFeatures,
+};
+const ALL_MODULE_KEYS = MODULE_KEYS;
+const KEY_TO_MODULE = Object.fromEntries(Object.keys(ALL_MODULE_KEYS).flatMap((moduleId) => ALL_MODULE_KEYS[moduleId].map((key) => [key, moduleId])));
+const guardUnsupportedProps = (props, modules, config, label) => {
+    const allowed = new Set();
+    modules.forEach((moduleId) => {
+        ALL_MODULE_KEYS[moduleId].forEach((key) => {
+            allowed.add(key);
+        });
+    });
+    Object.keys(props).forEach((key) => {
+        var _a, _b;
+        if (props[key] === undefined)
+            return;
+        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 = `Media query factory "${label}" received unsupported feature "${key}".${moduleSuffix}`;
+        if (mode === 'log') {
+            console.warn(message);
+            return;
+        }
+        if (mode === 'allow')
+            return;
+        throw new Error(message);
+    });
+};
+const normalizeCustomResult = (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 runCustomValidator = (props, config) => {
+    var _a, _b;
+    const custom = config.custom;
+    if (!(custom === null || custom === void 0 ? void 0 : custom.validator))
+        return;
+    const normalized = normalizeCustomResult(custom.validator(props));
+    if (normalized.valid)
+        return;
+    const mode = (_b = (_a = config.errorHandling) === null || _a === void 0 ? void 0 : _a.invalidValueMode) !== null && _b !== void 0 ? _b : 'throw';
+    const suffix = normalized.message ? `: ${normalized.message}` : '';
+    const message = `Media query factory "${config.label}" custom validator "${custom.key}" failed${suffix}`;
+    if (mode === 'log') {
+        console.warn(message);
+        return;
+    }
+    if (mode === 'allow')
+        return;
+    throw new Error(message);
+};
+const runCustomLinter = (props, config) => {
+    var _a, _b;
+    const custom = config.custom;
+    if (!(custom === null || custom === void 0 ? void 0 : custom.linter))
+        return;
+    const normalized = normalizeCustomResult(custom.linter(props));
+    if (normalized.valid)
+        return;
+    const mode = (_b = (_a = config.errorHandling) === null || _a === void 0 ? void 0 : _a.lintingMode) !== null && _b !== void 0 ? _b : 'throw';
+    const suffix = normalized.message ? `: ${normalized.message}` : '';
+    const message = `Media query factory "${config.label}" custom linter "${custom.key}" flagged${suffix}`;
+    if (mode === 'log') {
+        console.warn(message);
+        return;
+    }
+    if (mode === 'allow')
+        return;
+    throw new Error(message);
+};
+const createMediaQueryFactory = (emitters) => (options) => {
+    var _a;
+    const modules = (_a = options.config.modules) !== null && _a !== void 0 ? _a : ALL_MEDIA_QUERY_MODULES;
+    const buildMediaQuery = (0, helpers_1.createMediaQueryBuilder)({
+        emitBase: (props, helpers) => {
+            guardUnsupportedProps(props, modules, options.config, options.config.label);
+            runCustomValidator(props, options.config);
+            runCustomLinter(props, options.config);
+            modules.forEach((moduleId) => {
+                emitters[moduleId](props, helpers);
+            });
+        },
+        resolveType: (props) => props.type,
+        config: options.config,
+    });
+    return (stylesByQuery) => {
+        const result = {};
+        Object.keys(stylesByQuery).forEach((key) => {
+            const styles = stylesByQuery[key];
+            const props = options.queries[key];
+            if (!styles || !props)
+                return;
+            result[buildMediaQuery(props)] = styles;
+        });
+        const mediaQuery = {
+            '@media': result,
+        };
+        return options.config.output
+            ? options.config.output(mediaQuery)
+            : mediaQuery;
+    };
+};
+exports.createMediaQueryFactory = createMediaQueryFactory;
+exports.mediaQueryFactory = (0, exports.createMediaQueryFactory)(MODULE_EMITTERS);

package/dist/examples/src/mediaQueries/helpers.js

@@ -0,0 +1,88 @@
+"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 validation_1 = require("../validation");
+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 applyMediaQueryValidation = (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
+            ? `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/examples/src/mediaQueries/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("./types"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./factory"), exports);
+__exportStar(require("./mediaQueries"), exports);
+__exportStar(require("./modules"), exports);
+__exportStar(require("./moduleRegistry"), exports);
+__exportStar(require("../libraryHelpers/vanilla-extract"), exports);

package/dist/examples/src/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/examples/src/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/examples/src/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 : '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.runMediaQueryLint = runMediaQueryLint;

package/dist/examples/src/mediaQueries/mediaQueries.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMediaQueryStyle = exports.buildMediaQueryString = exports.emitCoreFeatures = exports.createEmitCoreFeatures = void 0;
+const helpers_1 = require("./helpers");
+const validation_1 = require("./validation");
+const modules_1 = require("./modules");
+const createEmitCoreFeatures = (validation) => (props, helpers) => {
+    const { runMediaQueryValidation, validateMinMaxWidth, validateWidthValuesPositive, } = validation;
+    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);
+    }
+};
+exports.createEmitCoreFeatures = createEmitCoreFeatures;
+exports.emitCoreFeatures = (0, exports.createEmitCoreFeatures)(validation_1.defaultMediaQueryValidation);
+const emitBaseFeatures = (props, helpers) => {
+    (0, exports.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/examples/src/mediaQueries/moduleRegistry.js

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

package/dist/examples/src/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;