zyzz 0.0.0 → 0.0.2

package/dist/react-native/StyleSheet.d.ts.map

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

package/dist/react-native/StyleSheet.js

@@ -0,0 +1,606 @@
+import * as Token from '../internal/Token.js';
+import * as Values from './internal/Values.js';
+import * as Color from './internal/Color.js';
+import * as Scalar from './internal/Scalar.js';
+const properties = Scalar.properties;
+/** Frozen native overlay style with zero physical offsets. */
+export const absoluteFill = Object.freeze({
+    bottom: 0,
+    left: 0,
+    position: 'absolute',
+    right: 0,
+    top: 0,
+});
+/** Failure to represent the supplied definitions on the native target. */
+export class CompileError extends Error {
+    /** Copies and freezes diagnostic paths in authored order. */
+    constructor(diagnostics) {
+        super(diagnostics
+            .map(({ message, path }) => `${JSON.stringify(path)}: ${message}`)
+            .join('\n'));
+        this.diagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
+            ...diagnostic,
+            path: Object.freeze([...diagnostic.path]),
+        })));
+    }
+    /** Target capability failures, including the selected table when relevant. */
+    diagnostics;
+    /** Stable namespaced error identifier. */
+    name = 'StyleSheet.CompileError';
+}
+/**
+ * Resolves portable tokens into two static scheme tables per supplied theme.
+ * px defaults to one native logical unit. rem and font families require mappings.
+ * No device state, CSS parser, stylesheet registration, or runtime binding is used.
+ * @throws {CompileError} For unsupported semantics or invalid conversion inputs.
+ */
+export function compile(options) {
+    for (const key of Object.keys(options))
+        if (!['fonts', 'platform', 'styles', 'themes', 'units'].includes(key))
+            fail('invalid_options', 'Unknown native compiler option.', [key]);
+    if (options.platform !== undefined &&
+        !['android', 'ios'].includes(options.platform))
+        fail('invalid_options', 'Expected an explicit ios or android platform.', [
+            'platform',
+        ]);
+    for (const [unit, scale] of Object.entries(options.units ?? {}))
+        if (!['px', 'rem'].includes(unit) ||
+            (scale !== undefined &&
+                (typeof scale !== 'number' || !Number.isFinite(scale) || scale <= 0)))
+            fail('invalid_options', 'Unit scales must be positive finite px or rem conversions.', ['units', unit]);
+    for (const [family, mapped] of Object.entries(options.fonts ?? {}))
+        if (!family || typeof mapped !== 'string' || !mapped.trim())
+            fail('invalid_options', 'Font mappings require nonempty family names.', [
+                'fonts',
+                family,
+            ]);
+    if (!options.styles || !Array.isArray(options.styles.styles))
+        fail('invalid_options', 'Expected a Style.define result.', ['styles']);
+    const names = new Set();
+    let scalar = true;
+    for (const style of options.styles.styles) {
+        if (!style.name || names.has(style.name))
+            fail('invalid_options', 'Style names must be nonempty and unique.', [
+                style.name,
+            ]);
+        names.add(style.name);
+        for (const part of sequence(style)) {
+            if ((part.targets?.android || part.targets?.ios) && !options.platform)
+                fail('invalid_options', 'Platform branches require an explicit platform.', [style.name, 'targets']);
+            const declared = new Set();
+            for (const declaration of part.declarations) {
+                if (typeof declaration.value !== 'number' &&
+                    typeof declaration.value !== 'string')
+                    scalar = false;
+                const path = [style.name, declaration.property];
+                if (!Object.hasOwn(properties, declaration.property))
+                    fail('unsupported_feature', 'Property is outside the native subset.', path);
+                if (declaration.important || declared.has(declaration.property))
+                    fail('unsupported_feature', 'Importance and fallback declarations are not supported on native.', path);
+                declared.add(declaration.property);
+            }
+        }
+    }
+    const themes = options.themes === undefined
+        ? [['default', undefined]]
+        : Object.entries(options.themes);
+    if (!themes.length)
+        fail('invalid_options', 'Supply at least one theme, or omit themes for a default table.', ['themes']);
+    const tables = Object.create(null);
+    const interned = new Map();
+    const diagnostics = [];
+    let independent;
+    for (const [label, theme] of themes) {
+        if (!label)
+            fail('invalid_options', 'Theme labels must be nonempty.', [
+                'themes',
+                label,
+            ]);
+        const metadata = theme &&
+            Object.getOwnPropertyDescriptor(theme, Token.definition)?.value;
+        if (options.themes !== undefined && !metadata)
+            fail('invalid_options', 'Expected a Theme.define or Config theme handle.', ['themes', label]);
+        const schemes = {};
+        const resolution = { schemeIndependent: true };
+        for (const scheme of ['light', 'dark']) {
+            if (independent) {
+                schemes[scheme] = independent;
+                continue;
+            }
+            if (scheme === 'dark' &&
+                resolution.schemeIndependent &&
+                !diagnostics.length) {
+                schemes.dark = schemes.light;
+                continue;
+            }
+            const compiled = Object.create(null);
+            for (const style of options.styles.styles) {
+                const output = {};
+                let lineHeight;
+                for (const part of sequence(style)) {
+                    for (const declaration of part.declarations) {
+                        const property = declaration.property;
+                        const path = [label, scheme, style.name, property];
+                        try {
+                            const value = resolve(declaration.value, metadata, scheme, path, resolution);
+                            if (property === 'lineHeight') {
+                                lineHeight = value;
+                                continue;
+                            }
+                            if (property === 'fontVariant') {
+                                if (typeof value !== 'string')
+                                    fail('unsupported_value', 'Expected static font variants.', path);
+                                try {
+                                    output.fontVariant = Values.parse({
+                                        fontVariant: value === 'normal' ? [] : value.trim().split(/\s+/),
+                                    }).fontVariant;
+                                }
+                                catch {
+                                    fail('unsupported_value', 'Font variant keywords require an explicit native equivalent.', path);
+                                }
+                                continue;
+                            }
+                            if (property === 'textShadow') {
+                                const entries = shadows(value, options, path, true);
+                                if (entries.length > 1)
+                                    fail('unsupported_value', 'Native text supports one shadow.', path);
+                                const shadow = entries[0];
+                                output.textShadowColor = shadow?.color ?? 'transparent';
+                                output.textShadowOffset = Object.freeze({
+                                    width: shadow?.offsetX ?? 0,
+                                    height: shadow?.offsetY ?? 0,
+                                });
+                                output.textShadowRadius = shadow?.blurRadius ?? 0;
+                                continue;
+                            }
+                            if (property === 'boxShadow') {
+                                output.boxShadow = shadows(value, options, path);
+                                continue;
+                            }
+                            if (property === 'transform') {
+                                output.transform = transform(value, options, path);
+                                continue;
+                            }
+                            if (property === 'transformOrigin') {
+                                output.transformOrigin = origin(value, options, path);
+                                continue;
+                            }
+                            const kind = properties[property];
+                            const converted = convert(kind, value, options, path);
+                            if (property === 'padding' || property === 'margin') {
+                                const values = typeof value === 'string'
+                                    ? value.trim().split(/\s+/)
+                                    : [value];
+                                const [top, right = top, bottom = top, left = right] = values.map((value) => length(value, options, property === 'margin', path));
+                                output[`${property}Top`] = top;
+                                output[`${property}Right`] = right;
+                                output[`${property}Bottom`] = bottom;
+                                output[`${property}Left`] = left;
+                            }
+                            else if (property === 'borderColor' ||
+                                property === 'borderWidth') {
+                                for (const side of ['Top', 'Right', 'Bottom', 'Left'])
+                                    output[`border${side}${property === 'borderColor' ? 'Color' : 'Width'}`] = converted;
+                            }
+                            else if (property === 'borderRadius') {
+                                for (const corner of [
+                                    'TopLeft',
+                                    'TopRight',
+                                    'BottomRight',
+                                    'BottomLeft',
+                                ])
+                                    output[`border${corner}Radius`] = converted;
+                            }
+                            else if (property === 'gap') {
+                                output.columnGap = converted;
+                                output.rowGap = converted;
+                            }
+                            else
+                                output[property] = converted;
+                        }
+                        catch (error) {
+                            if (!(error instanceof CompileError))
+                                throw error;
+                            diagnostics.push(...error.diagnostics);
+                        }
+                    }
+                    for (const branch of ['native', options.platform]) {
+                        if (!branch || !part.targets?.[branch])
+                            continue;
+                        try {
+                            const native = Values.parse(part.targets[branch]);
+                            Object.assign(output, native);
+                            if (native.lineHeight !== undefined)
+                                lineHeight = undefined;
+                        }
+                        catch (error) {
+                            if (error instanceof CompileError)
+                                throw error;
+                            diagnostics.push({
+                                code: 'unsupported_value',
+                                message: error.message,
+                                path: [label, scheme, style.name, 'targets', branch],
+                            });
+                        }
+                    }
+                }
+                if (lineHeight !== undefined) {
+                    const path = [label, scheme, style.name, 'lineHeight'];
+                    try {
+                        if (typeof lineHeight === 'number') {
+                            if (!Number.isFinite(lineHeight) ||
+                                lineHeight < 0 ||
+                                typeof output.fontSize !== 'number')
+                                fail('unsupported_value', 'Numeric lineHeight requires an explicit fontSize in the same style.', path);
+                            output.lineHeight = lineHeight * output.fontSize;
+                            if (!Number.isFinite(output.lineHeight))
+                                fail('unsupported_value', 'Converted lineHeight must be finite.', path);
+                        }
+                        else
+                            output.lineHeight = length(lineHeight, options, false, path);
+                    }
+                    catch (error) {
+                        if (!(error instanceof CompileError))
+                            throw error;
+                        diagnostics.push(...error.diagnostics);
+                    }
+                }
+                const key = JSON.stringify(Object.entries(output).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+                let shared = interned.get(key);
+                if (!shared) {
+                    shared = Object.freeze(output);
+                    interned.set(key, shared);
+                }
+                compiled[style.name] = shared;
+            }
+            schemes[scheme] = Object.freeze(compiled);
+            if (scalar && !diagnostics.length)
+                independent = schemes[scheme];
+        }
+        tables[label] = Object.freeze(schemes);
+    }
+    if (diagnostics.length)
+        throw new CompileError(diagnostics);
+    return Object.freeze({
+        styles: Object.freeze(tables),
+    });
+}
+export function compose(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    return [first, second];
+}
+export function flatten(styles) {
+    if (!styles || typeof styles !== 'object')
+        return undefined;
+    if (!Array.isArray(styles))
+        return styles;
+    const result = {};
+    for (const style of styles) {
+        const flattened = flatten(style);
+        if (!flattened)
+            continue;
+        // Native flattening includes enumerable inherited declarations.
+        for (const key in flattened)
+            Object.defineProperty(result, key, {
+                configurable: true,
+                enumerable: true,
+                value: flattened[key],
+                writable: true,
+            });
+    }
+    return result;
+}
+export function select(styles, options) {
+    if (!styles ||
+        !options ||
+        (options.colorScheme !== 'light' && options.colorScheme !== 'dark') ||
+        !Object.hasOwn(styles, options.theme))
+        throw new SelectionError('Select an existing theme label and light or dark colorScheme.');
+    return styles[options.theme][options.colorScheme];
+}
+/** Rejected lookup of a precompiled native table. */
+export class SelectionError extends Error {
+    /** Explains the invalid selection without compiling replacement styles. */
+    constructor(message) {
+        super(message);
+    }
+    /** Stable namespaced error identifier. */
+    name = 'StyleSheet.SelectionError';
+}
+function convert(kind, value, options, path) {
+    try {
+        return Scalar.convert(kind, value, options, path);
+    }
+    catch (error) {
+        fail('unsupported_value', error.message, path);
+    }
+}
+function fail(code, message, path) {
+    throw new CompileError([{ code, message, path }]);
+}
+function length(value, options, signed, path) {
+    try {
+        return Scalar.length(value, options, signed, path);
+    }
+    catch (error) {
+        fail('unsupported_value', error.message, path);
+    }
+}
+function origin(value, options, path) {
+    const parts = String(value).trim().toLowerCase().split(/\s+/);
+    if (!parts[0] || parts.length > 3)
+        fail('unsupported_value', 'Expected one to three transform-origin values.', path);
+    let [x, y = 'center', z = '0'] = parts;
+    const horizontal = ['left', 'center', 'right'];
+    const vertical = ['top', 'center', 'bottom'];
+    if (parts.length === 1 && (x === 'top' || x === 'bottom'))
+        [x, y] = ['center', x];
+    else if (x === 'top' || x === 'bottom' || y === 'left' || y === 'right') {
+        if (!vertical.includes(x) || !horizontal.includes(y))
+            fail('unsupported_value', 'Transform-origin keywords must identify different axes.', path);
+        [x, y] = [y, x];
+    }
+    const values = [x, y].map((part, index) => {
+        const keywords = index === 0 ? horizontal : vertical;
+        const keyword = keywords.indexOf(part);
+        if (keyword !== -1)
+            return `${keyword * 50}%`;
+        if (/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)%$/.test(part)) {
+            if (!Number.isFinite(Number(part.slice(0, -1))))
+                fail('unsupported_value', 'Transform-origin percentages must be finite.', path);
+            return part;
+        }
+        return length(part, options, true, path);
+    });
+    // Native declares mutable origin arrays but reads them without mutation. Compiler-owned tuples remain frozen.
+    return Object.freeze([
+        values[0],
+        values[1],
+        length(z, options, true, path),
+    ]);
+}
+function resolve(value, metadata, scheme, path, resolution) {
+    if (typeof value === 'number' || typeof value === 'string')
+        return value;
+    if (!Token.is(value) ||
+        Object.getOwnPropertyDescriptor(value, Token.web)?.value)
+        fail('unsupported_feature', 'Web variables, expressions, and dynamic bindings are not native scalar tokens.', path);
+    const shared = metadata &&
+        (metadata.contract === value.contract ||
+            (metadata.contract[Token.identity] !== undefined &&
+                metadata.contract[Token.identity] === value.contract[Token.identity]));
+    const resolved = shared
+        ? Object.hasOwn(metadata.values, value.path)
+            ? metadata.values[value.path]
+            : undefined
+        : value.value;
+    if (resolved === undefined)
+        fail('unsupported_value', 'Theme is missing a live token.', path);
+    if (typeof resolved === 'object' && resolved.light !== resolved.dark)
+        resolution.schemeIndependent = false;
+    const scalar = typeof resolved === 'object' ? resolved[scheme] : resolved;
+    if (typeof scalar !== 'string' && typeof scalar !== 'number')
+        fail('unsupported_value', 'Expected a complete scalar color-scheme pair.', path);
+    return scalar;
+}
+function transform(value, options, path) {
+    if (typeof value !== 'string' || !value.trim())
+        fail('unsupported_value', 'Expected a static transform list.', path);
+    let remaining = value.trim();
+    const output = [];
+    if (remaining === 'none')
+        return Object.freeze(output);
+    while (remaining) {
+        const match = /^([a-z][a-z0-9]*)\(([^()]*)\)/i.exec(remaining);
+        if (!match)
+            fail('unsupported_value', 'Expected literal transform arguments.', path);
+        const name = match[1].toLowerCase();
+        const args = match[2].split(',').map((argument) => argument.trim());
+        const limit = name === 'matrix'
+            ? 6
+            : name === 'matrix3d'
+                ? 16
+                : name === 'translate' || name === 'scale'
+                    ? 2
+                    : 1;
+        if (!args[0] || args.length > limit || args.some((arg) => !arg))
+            fail('unsupported_value', 'Invalid transform argument count.', path);
+        const argument = args[0];
+        if (name === 'matrix' || name === 'matrix3d') {
+            if (args.length !== limit ||
+                args.some((arg) => !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(arg) ||
+                    !Number.isFinite(Number(arg))))
+                fail('unsupported_value', 'Matrices require six or sixteen finite numbers.', path);
+            const values = args.map(Number);
+            const matrix = name === 'matrix'
+                ? [
+                    values[0],
+                    values[1],
+                    0,
+                    0,
+                    values[2],
+                    values[3],
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    values[4],
+                    values[5],
+                    0,
+                    1,
+                ]
+                : values;
+            const px = options.units?.px ?? 1;
+            // Conjugate the matrix by the length scale, including projective components.
+            for (const index of [12, 13, 14])
+                matrix[index] = matrix[index] * px;
+            for (const index of [3, 7, 11])
+                matrix[index] = matrix[index] / px;
+            if (!matrix.every(Number.isFinite))
+                fail('unsupported_value', 'Converted matrix values must be finite.', path);
+            Object.freeze(matrix);
+            output.push({ matrix });
+        }
+        else if (name === 'translate' ||
+            name === 'translatex' ||
+            name === 'translatey') {
+            const values = args.map((arg) => {
+                if (/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)%$/.test(arg)) {
+                    if (!Number.isFinite(Number(arg.slice(0, -1))))
+                        fail('unsupported_value', 'Transform percentages must be finite.', path);
+                    return arg;
+                }
+                return length(arg, options, true, path);
+            });
+            if (name === 'translatey')
+                output.push({ translateY: values[0] });
+            else {
+                output.push({ translateX: values[0] });
+                if (name === 'translate')
+                    output.push({ translateY: values[1] ?? 0 });
+            }
+        }
+        else if (name === 'scale' || name === 'scalex' || name === 'scaley') {
+            const values = args.map((arg) => {
+                if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(arg) ||
+                    !Number.isFinite(Number(arg)))
+                    fail('unsupported_value', 'Scale requires finite numbers.', path);
+                return Number(arg);
+            });
+            if (name === 'scale' && values.length === 1)
+                output.push({ scale: values[0] });
+            else if (name === 'scaley')
+                output.push({ scaleY: values[0] });
+            else {
+                output.push({ scaleX: values[0] });
+                if (name === 'scale')
+                    output.push({ scaleY: values[1] });
+            }
+        }
+        else if (['rotate', 'rotatex', 'rotatey', 'rotatez', 'skewx', 'skewy'].includes(name)) {
+            const angle = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(deg|grad|rad|turn)$/i.exec(argument);
+            if (!angle && argument !== '0')
+                fail('unsupported_value', 'Rotation and skew require literal angles.', path);
+            const unit = angle?.[2]?.toLowerCase() ?? 'deg';
+            const number = Number(angle?.[1] ?? 0) *
+                (unit === 'turn' ? 360 : unit === 'grad' ? 0.9 : 1);
+            if (!Number.isFinite(number))
+                fail('unsupported_value', 'Transform angles must be finite.', path);
+            const converted = `${number}${unit === 'rad' ? 'rad' : 'deg'}`;
+            const property = name === 'rotate'
+                ? name
+                : `${name.slice(0, -1)}${name.at(-1).toUpperCase()}`;
+            // Native transform entries have one key. Normalize CSS's case-insensitive function names.
+            output.push({ [property]: converted });
+        }
+        else if (name === 'perspective') {
+            const distance = length(argument, options, false, path);
+            // CSS clamps perspective distances below one CSS pixel before unit conversion.
+            output.push({ perspective: Math.max(distance, options.units?.px ?? 1) });
+        }
+        else
+            fail('unsupported_feature', 'Transform function is outside the native subset.', [...path, match[1]]);
+        remaining = remaining.slice(match[0].length).trimStart();
+    }
+    if (output.length > 1 && output.some((entry) => 'matrix' in entry)) {
+        let combined = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        for (const entry of output) {
+            const matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+            const [key, value] = Object.entries(entry)[0];
+            if (key === 'matrix')
+                matrix.splice(0, 16, ...value);
+            else if (key.startsWith('translate')) {
+                if (typeof value !== 'number')
+                    fail('unsupported_value', 'Matrix composition requires absolute translations.', path);
+                matrix[key === 'translateX' ? 12 : 13] = value;
+            }
+            else if (key === 'perspective')
+                matrix[11] = -1 / value;
+            else if (key.startsWith('scale')) {
+                if (key !== 'scaleY')
+                    matrix[0] = value;
+                if (key !== 'scaleX')
+                    matrix[5] = value;
+            }
+            else {
+                const angle = Number.parseFloat(value) *
+                    (value.endsWith('rad') ? 1 : Math.PI / 180);
+                if (key === 'skewX')
+                    matrix[4] = Math.tan(angle);
+                else if (key === 'skewY')
+                    matrix[1] = Math.tan(angle);
+                else {
+                    const [a, b] = key === 'rotateX' ? [1, 2] : key === 'rotateY' ? [2, 0] : [0, 1];
+                    matrix[a * 4 + a] = Math.cos(angle);
+                    matrix[b * 4 + b] = Math.cos(angle);
+                    matrix[a * 4 + b] = Math.sin(angle);
+                    matrix[b * 4 + a] = -Math.sin(angle);
+                }
+            }
+            combined = combined.map((_, index) => {
+                const row = index % 4;
+                const column = Math.floor(index / 4);
+                return [0, 1, 2, 3].reduce((sum, k) => sum + combined[k * 4 + row] * matrix[column * 4 + k], 0);
+            });
+        }
+        if (!combined.every(Number.isFinite))
+            fail('unsupported_value', 'Converted matrix values must be finite.', path);
+        Object.freeze(combined);
+        // React Native requires a matrix to be the only transform entry.
+        return Object.freeze([Object.freeze({ matrix: combined })]);
+    }
+    return Object.freeze(output.map((entry) => Object.freeze(entry)));
+}
+function shadows(value, options, path, text = false) {
+    if (value === 'none')
+        return Object.freeze([]);
+    if (typeof value !== 'string')
+        fail('unsupported_value', 'Expected a static shadow list.', path);
+    return Object.freeze(value.split(/,(?![^()]*\))/).map((shadow) => {
+        const parts = shadow.trim().match(/[a-z]+\([^()]*\)|[^\s]+/gi) ?? [];
+        const lengths = [];
+        let color;
+        let inset = false;
+        for (const part of parts) {
+            if (part === 'inset' && !inset) {
+                inset = true;
+                continue;
+            }
+            const parsed = Color.parse(part);
+            if (parsed !== undefined && color === undefined) {
+                color = parsed;
+                continue;
+            }
+            lengths.push(length(part, options, true, path));
+        }
+        if (lengths.length < 2 ||
+            lengths.length > (text ? 3 : 4) ||
+            (text && inset) ||
+            (lengths[2] ?? 0) < 0 ||
+            color === undefined)
+            fail('unsupported_value', 'Shadows require two to four lengths, a nonnegative blur, and an explicit absolute color.', path);
+        return Object.freeze({
+            offsetX: lengths[0],
+            offsetY: lengths[1],
+            blurRadius: lengths[2] ?? 0,
+            spreadDistance: lengths[3] ?? 0,
+            color,
+            inset,
+        });
+    }));
+}
+function sequence(style) {
+    const parts = [style];
+    for (const rule of style.rules ?? []) {
+        if (rule.condition !== undefined)
+            fail('unsupported_feature', 'Selectors, queries, and nested rules are not supported on native.', [style.name]);
+        parts.push(...sequence(rule.style));
+    }
+    return parts;
+}
+//# sourceMappingURL=StyleSheet.js.map