css-calipers 0.9.3 → 0.9.4

package/dist/esm/containerQueries/validation.js

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

package/dist/esm/core.d.ts

@@ -1,4 +1,5 @@
-import { type UnitCategory, type UnitDefinition, type UnitDefinitionRecord, type UnitHelperName } from './unitDefinitions';
+import { type UnitCategory, type UnitDefinition, type UnitDefinitionRecord } from './unitDefinitions';
+import { type ErrorConfig, type ErrorCode } from './internal/errors';
 type UnitSymbol = UnitDefinitionRecord[keyof UnitDefinitionRecord]['unit'];
 export type MeasurementString<Unit extends string = UnitSymbol> = `${number}${Unit}`;
 type UnitBrand<Unit extends string> = {
@@ -16,8 +17,8 @@ export interface IMeasurement<Unit extends string = string> {
     assert: (predicate: (measurement: IMeasurement<Unit>) => boolean, message: string) => void;
     equals: (other: IMeasurement<string>) => boolean;
     compare: (other: IMeasurement<string>) => number;
-    add: (delta: DeltaInput) => IMeasurement<Unit>;
-    subtract: (delta: DeltaInput) => IMeasurement<Unit>;
+    add: (delta: number | IMeasurement<string>) => IMeasurement<Unit>;
+    subtract: (delta: number | IMeasurement<string>) => IMeasurement<Unit>;
     multiply: (factor: number) => IMeasurement<Unit>;
     divide: (divisor: number) => IMeasurement<Unit>;
     double: () => IMeasurement<Unit>;
@@ -29,18 +30,28 @@ export interface IMeasurement<Unit extends string = string> {
     ceil: () => IMeasurement<Unit>;
     clamp: (min: IMeasurement<string>, max: IMeasurement<string>) => IMeasurement<Unit>;
 }
-type DeltaInput = number | IMeasurement<string>;
-export declare function assertMatchingUnits<Unit extends string>(left: IMeasurement<Unit>, right: IMeasurement<Unit>, context: string): void;
-export declare const isMeasurement: (x: unknown) => x is IMeasurement<string>;
-export declare function m(value: number): BrandedMeasurement<'px'>;
-export declare function m<Unit extends string>(value: number, unit: Unit): IMeasurement<Lowercase<Unit>> & UnitBrand<Lowercase<Unit>>;
 export type BrandedMeasurement<Unit extends string> = IMeasurement<Unit> & UnitBrand<Unit>;
-export type UnitHelper<Unit extends string = string> = ((value: number) => BrandedMeasurement<Unit>) & {
+export type UnitHelper<Unit extends string = string> = ((value: number, context?: string) => BrandedMeasurement<Unit>) & {
     unit: Unit;
 };
-export declare const makeUnitHelper: <Unit extends string>(unit: Unit) => UnitHelper<Unit>;
-export declare const makeUnitHelperFromDefinition: <Name extends UnitHelperName>(name: Name) => UnitHelper<UnitDefinitionRecord[Name]["unit"]>;
-export declare const measurementUnitMetadata: {
+export type MeasurementOf<T extends UnitHelper> = ReturnType<T>;
+export type UnitGuard<T extends UnitHelper> = (value: unknown) => value is MeasurementOf<T>;
+export type UnitAssertion<T extends UnitHelper> = (value: unknown, context?: string) => asserts value is MeasurementOf<T>;
+export declare const m: {
+    (value: number): BrandedMeasurement<"px">;
+    (value: number, options: {
+        context?: string;
+    }): BrandedMeasurement<"px">;
+    <Unit extends string>(value: number, unit: Unit, context?: string): IMeasurement<Lowercase<Unit>> & {
+        readonly __unitBrand: Lowercase<Unit>;
+    };
+    <Unit extends string>(value: number, options: {
+        unit?: Unit | undefined;
+        context?: string;
+    }): IMeasurement<Lowercase<Unit>> & {
+        readonly __unitBrand: Lowercase<Unit>;
+    };
+}, isMeasurement: (x: unknown) => x is IMeasurement<string>, assertMatchingUnits: <Unit extends string>(left: IMeasurement<Unit>, right: IMeasurement<Unit>, context: string) => void, measurementMin: <Unit extends string>(a: IMeasurement<Unit>, b: IMeasurement<Unit>) => IMeasurement<Unit>, measurementMax: <Unit extends string>(a: IMeasurement<Unit>, b: IMeasurement<Unit>) => IMeasurement<Unit>, measurementUnitMetadata: {
     readonly mPercent: {
         readonly unit: "%";
         readonly category: "percent";
@@ -289,20 +300,10 @@ export declare const measurementUnitMetadata: {
         readonly unit: "fr";
         readonly category: "flex";
     };
-};
+}, makeUnitHelper: <Unit extends string>(unit: Unit) => UnitHelper<Unit>, makeUnitHelperFromDefinition: <Name extends import("./unitDefinitions").UnitHelperName>(name: Name) => UnitHelper<UnitDefinitionRecord[Name]["unit"]>, makeUnitGuard: <T extends UnitHelper>(helper: T) => UnitGuard<T>, makeUnitAssert: <T extends UnitHelper>(helper: T) => UnitAssertion<T>, hasCssMethod: (x: unknown) => x is {
+    css: () => string;
+}, assertUnit: <Unit extends string>(measurement: IMeasurement<Unit>, expectedUnit: string, context?: string) => void, assertCondition: (condition: boolean | (() => boolean), message: string) => void, getErrorConfig: () => Required<ErrorConfig>, setErrorConfig: (next: ErrorConfig) => void;
 export type MeasurementUnitDefinition = UnitDefinition;
 export type MeasurementUnitCategory = UnitCategory;
-export type MeasurementOf<T extends UnitHelper> = ReturnType<T>;
-export type UnitGuard<T extends UnitHelper> = (value: unknown) => value is MeasurementOf<T>;
-export type UnitAssertion<T extends UnitHelper> = (value: unknown, context?: string) => asserts value is MeasurementOf<T>;
-export declare const makeUnitGuard: <T extends UnitHelper>(helper: T) => UnitGuard<T>;
-export declare const makeUnitAssert: <T extends UnitHelper>(helper: T) => UnitAssertion<T>;
-export declare const hasCssMethod: (x: unknown) => x is {
-    css: () => string;
-};
-export declare const measurementMin: <Unit extends string>(a: IMeasurement<Unit>, b: IMeasurement<Unit>) => IMeasurement<Unit>;
-export declare const measurementMax: <Unit extends string>(a: IMeasurement<Unit>, b: IMeasurement<Unit>) => IMeasurement<Unit>;
-export declare const assertUnit: <Unit extends string>(measurement: IMeasurement<Unit>, expectedUnit: string, context?: string) => void;
-export declare const assertCondition: (condition: boolean | (() => boolean), message: string) => void;
-export {};
+export { type ErrorConfig, type ErrorCode };
 //# sourceMappingURL=core.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core.ts"],"names":[],"mappings":"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"}

package/dist/esm/core.js

@@ -1,266 +1,5 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Measurement_instances, _a, _Measurement_value, _Measurement_unit, _Measurement_clone;
-import { UNIT_DEFINITIONS, } from './unitDefinitions';
-import { throwHelperError, throwMeasurementMethodError, } from './internal/errors';
-export function assertMatchingUnits(left, right, context) {
-    const leftUnit = left.getUnit();
-    const rightUnit = right.getUnit();
-    if (leftUnit !== rightUnit) {
-        throwHelperError({
-            operation: 'css-calipers.assertMatchingUnits',
-            params: [left, right],
-            message: `measurement unit mismatch: ${leftUnit} vs ${rightUnit}`,
-            context,
-        });
-    }
-}
-const deltaToNumber = (base, delta) => {
-    if (typeof delta === 'number')
-        return delta;
-    assertMatchingUnits(base, delta, 'deltaToNumber');
-    return delta.getValue();
-};
-class Measurement {
-    constructor(value, unit) {
-        _Measurement_instances.add(this);
-        _Measurement_value.set(this, void 0);
-        _Measurement_unit.set(this, void 0);
-        if (!Number.isFinite(value)) {
-            throwHelperError({
-                operation: 'css-calipers.Measurement.constructor',
-                params: [],
-                message: `Non-finite measurement value: ${value}`,
-            });
-        }
-        const normalizedUnit = unit.toLowerCase();
-        __classPrivateFieldSet(this, _Measurement_value, value, "f");
-        __classPrivateFieldSet(this, _Measurement_unit, normalizedUnit, "f");
-        Object.defineProperty(this, '__unitBrand', {
-            value: normalizedUnit,
-            enumerable: false,
-            configurable: false,
-            writable: false,
-        });
-    }
-    css() {
-        return `${__classPrivateFieldGet(this, _Measurement_value, "f")}${__classPrivateFieldGet(this, _Measurement_unit, "f")}`;
-    }
-    toString() {
-        return this.css();
-    }
-    getUnit() {
-        return __classPrivateFieldGet(this, _Measurement_unit, "f");
-    }
-    getValue() {
-        return __classPrivateFieldGet(this, _Measurement_value, "f");
-    }
-    valueOf() {
-        return __classPrivateFieldGet(this, _Measurement_value, "f");
-    }
-    [(_Measurement_value = new WeakMap(), _Measurement_unit = new WeakMap(), _Measurement_instances = new WeakSet(), Symbol.toPrimitive)](hint) {
-        if (hint === 'number')
-            return __classPrivateFieldGet(this, _Measurement_value, "f");
-        return this.css();
-    }
-    isUnit(expected) {
-        return __classPrivateFieldGet(this, _Measurement_unit, "f") === expected.toLowerCase();
-    }
-    assertUnit(expected, context) {
-        if (!this.isUnit(expected)) {
-            throwMeasurementMethodError({
-                operation: 'css-calipers.Measurement.assertUnit',
-                caller: this,
-                params: [],
-                message: `Expected unit "${expected}", received "${__classPrivateFieldGet(this, _Measurement_unit, "f")}".`,
-                context,
-            });
-        }
-    }
-    assert(predicate, message) {
-        if (!predicate(this)) {
-            throwMeasurementMethodError({
-                operation: 'css-calipers.Measurement.assert',
-                caller: this,
-                params: [],
-                message,
-            });
-        }
-    }
-    equals(other, strict = true) {
-        const otherUnit = other.getUnit();
-        if (__classPrivateFieldGet(this, _Measurement_unit, "f") !== otherUnit) {
-            if (strict) {
-                assertMatchingUnits(this, other, 'equals(strict)');
-            }
-            return false;
-        }
-        return __classPrivateFieldGet(this, _Measurement_value, "f") === other.getValue();
-    }
-    compare(other, strict = true) {
-        if (strict) {
-            assertMatchingUnits(this, other, 'compare(strict)');
-        }
-        else if (__classPrivateFieldGet(this, _Measurement_unit, "f") !== other.getUnit()) {
-            return __classPrivateFieldGet(this, _Measurement_unit, "f") < other.getUnit() ? -1 : 1;
-        }
-        const diff = __classPrivateFieldGet(this, _Measurement_value, "f") - other.getValue();
-        if (diff === 0)
-            return 0;
-        return diff < 0 ? -1 : 1;
-    }
-    add(delta) {
-        const next = __classPrivateFieldGet(this, _Measurement_value, "f") + deltaToNumber(this, delta);
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
-    }
-    subtract(delta) {
-        const next = __classPrivateFieldGet(this, _Measurement_value, "f") - deltaToNumber(this, delta);
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
-    }
-    multiply(factor) {
-        if (factor === 1)
-            return this;
-        if (factor === 0)
-            return new _a(0, __classPrivateFieldGet(this, _Measurement_unit, "f"));
-        if (factor === -1)
-            return new _a(-__classPrivateFieldGet(this, _Measurement_value, "f"), __classPrivateFieldGet(this, _Measurement_unit, "f"));
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") * factor);
-    }
-    divide(divisor) {
-        if (divisor === 1)
-            return this;
-        if (divisor === 0) {
-            throwMeasurementMethodError({
-                operation: 'css-calipers.Measurement.divide',
-                caller: this,
-                params: [],
-                message: `Cannot divide ${this.css()} by zero`,
-            });
-        }
-        const result = __classPrivateFieldGet(this, _Measurement_value, "f") / divisor;
-        if (!Number.isFinite(result)) {
-            throwMeasurementMethodError({
-                operation: 'css-calipers.Measurement.divide',
-                caller: this,
-                params: [],
-                message: 'Non-finite result',
-            });
-        }
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, result);
-    }
-    double() {
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") * 2);
-    }
-    half() {
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") / 2);
-    }
-    negation(shouldNegate = true) {
-        return shouldNegate ? __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, -__classPrivateFieldGet(this, _Measurement_value, "f")) : this;
-    }
-    absolute() {
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.abs(__classPrivateFieldGet(this, _Measurement_value, "f")));
-    }
-    round(precision = 0) {
-        const next = precision === 0
-            ? Math.round(__classPrivateFieldGet(this, _Measurement_value, "f"))
-            : Number(__classPrivateFieldGet(this, _Measurement_value, "f").toFixed(precision));
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
-    }
-    floor() {
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.floor(__classPrivateFieldGet(this, _Measurement_value, "f")));
-    }
-    ceil() {
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.ceil(__classPrivateFieldGet(this, _Measurement_value, "f")));
-    }
-    clamp(min, max) {
-        assertMatchingUnits(this, min, 'clamp(min)');
-        assertMatchingUnits(this, max, 'clamp(max)');
-        const minValue = min.getValue();
-        const maxValue = max.getValue();
-        if (!Number.isFinite(minValue) || !Number.isFinite(maxValue)) {
-            throwMeasurementMethodError({
-                operation: 'css-calipers.Measurement.clamp',
-                caller: this,
-                params: [min, max],
-                message: 'clamp: expected finite bounds',
-            });
-        }
-        if (minValue > maxValue) {
-            throwMeasurementMethodError({
-                operation: 'css-calipers.Measurement.clamp',
-                caller: this,
-                params: [min, max],
-                message: `clamp: min (${min.css()}) must be <= max (${max.css()})`,
-            });
-        }
-        const clamped = Math.min(maxValue, Math.max(minValue, __classPrivateFieldGet(this, _Measurement_value, "f")));
-        return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, clamped);
-    }
-}
-_a = Measurement, _Measurement_clone = function _Measurement_clone(value) {
-    return new _a(value, __classPrivateFieldGet(this, _Measurement_unit, "f"));
-};
-const createMeasurement = (value, unit) => new Measurement(value, unit);
-export const isMeasurement = (x) => x instanceof Measurement;
-export function m(value, unit = 'px') {
-    return createMeasurement(value, unit.toLowerCase());
-}
-export const makeUnitHelper = (unit) => {
-    const normalizedUnit = unit.toLowerCase();
-    const factory = (value) => createMeasurement(value, normalizedUnit);
-    return Object.assign(factory, {
-        unit: normalizedUnit,
-    });
-};
-export const makeUnitHelperFromDefinition = (name) => makeUnitHelper(UNIT_DEFINITIONS[name].unit);
-export const measurementUnitMetadata = UNIT_DEFINITIONS;
-export const makeUnitGuard = (helper) => {
-    return (value) => isMeasurement(value) && value.isUnit(helper.unit);
-};
-export const makeUnitAssert = (helper) => {
-    const guard = makeUnitGuard(helper);
-    return (value, context) => {
-        if (!guard(value)) {
-            throwHelperError({
-                operation: 'css-calipers.makeUnitAssert',
-                params: isMeasurement(value) ? [value] : [],
-                message: `Expected unit "${helper.unit}".`,
-                context,
-            });
-        }
-    };
-};
-export const hasCssMethod = (x) => {
-    return (typeof x === 'object' &&
-        x !== null &&
-        'css' in x &&
-        typeof x.css === 'function');
-};
-export const measurementMin = (a, b) => {
-    assertMatchingUnits(a, b, 'measurementMin');
-    return a.getValue() <= b.getValue() ? a : b;
-};
-export const measurementMax = (a, b) => {
-    assertMatchingUnits(a, b, 'measurementMax');
-    return a.getValue() >= b.getValue() ? a : b;
-};
-export const assertUnit = (measurement, expectedUnit, context) => measurement.assertUnit(expectedUnit, context);
-export const assertCondition = (condition, message) => {
-    const passed = typeof condition === 'function' ? condition() : condition;
-    if (!passed) {
-        throwHelperError({
-            operation: 'css-calipers.assertCondition',
-            params: [],
-            message,
-        });
-    }
-};
+import { createCoreApi } from './internal/createCoreApi';
+import { createErrorConfigStore, } from './internal/errors';
+const defaultErrorStore = createErrorConfigStore();
+const coreApi = createCoreApi(defaultErrorStore);
+export const { m, isMeasurement, assertMatchingUnits, measurementMin, measurementMax, measurementUnitMetadata, makeUnitHelper, makeUnitHelperFromDefinition, makeUnitGuard, makeUnitAssert, hasCssMethod, assertUnit, assertCondition, getErrorConfig, setErrorConfig, } = coreApi;

package/dist/esm/factory.d.ts

@@ -0,0 +1,13 @@
+import { type ErrorConfig } from './internal/errors';
+import { type CoreApi } from './internal/createCoreApi';
+import { type UnitsApi } from './internal/createUnitsApi';
+import { type MediaQueriesApi } from './internal/createMediaQueriesApi';
+export type CalipersFactoryConfig = {
+    errorConfig?: ErrorConfig;
+};
+export type CalipersInstance = CoreApi & UnitsApi & {
+    mediaQueries: MediaQueriesApi;
+    units: UnitsApi;
+};
+export declare const createCalipers: (config?: CalipersFactoryConfig) => CalipersInstance;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,kCAAkC,CAAC;AAE1C,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,GACpC,QAAQ,GAAG;IACT,YAAY,EAAE,eAAe,CAAC;IAC9B,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AAEJ,eAAO,MAAM,cAAc,GACzB,SAAQ,qBAA0B,KACjC,gBAcF,CAAC"}

package/dist/esm/factory.js

@@ -0,0 +1,17 @@
+import { createErrorConfigStore } from './internal/errors';
+import { createCoreApi } from './internal/createCoreApi';
+import { createUnitsApi } from './internal/createUnitsApi';
+import { createMediaQueriesApi, } from './internal/createMediaQueriesApi';
+export const createCalipers = (config = {}) => {
+    var _a;
+    const errorStore = createErrorConfigStore((_a = config.errorConfig) !== null && _a !== void 0 ? _a : {});
+    const core = createCoreApi(errorStore);
+    const units = createUnitsApi(core);
+    const mediaQueries = createMediaQueriesApi(core);
+    return {
+        ...core,
+        ...units,
+        mediaQueries,
+        units,
+    };
+};

package/dist/esm/fraction.d.ts

@@ -0,0 +1,23 @@
+export interface IFraction {
+    css: () => string;
+    toString: () => string;
+    valueOf: () => number;
+    numerator: () => number;
+    denominator: () => number;
+    withNumerator: (numerator: number) => IFraction;
+    withDenominator: (denominator: number) => IFraction;
+}
+export type Fraction = IFraction;
+export type RatioParts = {
+    numerator: number;
+    denominator: number;
+};
+export declare function r(denominator: number): Fraction;
+export declare function r(numerator: number, denominator: number): Fraction;
+export declare const isFraction: (value: unknown) => value is IFraction;
+export declare const parseRatio: (value: number | string | IFraction) => RatioParts | null;
+export declare const normalizeFraction: (fraction: IFraction) => IFraction;
+export declare const reduceFraction: (fraction: IFraction) => IFraction;
+export declare const simplifyFraction: (fraction: IFraction) => IFraction;
+export declare const fractionToFloat: (fraction: IFraction) => number;
+//# sourceMappingURL=fraction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fraction.d.ts","sourceRoot":"","sources":["../../src/fraction.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,MAAM,CAAC;IAC1B,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,SAAS,CAAC;IAChD,eAAe,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,SAAS,CAAC;CACrD;AAED,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC;AAEjC,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAwDF,wBAAgB,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC;AACjD,wBAAgB,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC;AAUpE,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,SAWpD,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,SAAS,KAAG,UAAU,GAAG,IAoB5E,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,UAAU,SAAS,KAAG,SAiCvD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,UAAU,SAAS,KAAG,SACxB,CAAC;AAE9B,eAAO,MAAM,gBAAgB,GAAI,UAAU,SAAS,KAAG,SAOtD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,UAAU,SAAS,KAAG,MACP,CAAC"}