@peekling/runtime 0.1.0

package/dist/pack.js

@@ -0,0 +1,316 @@
+import { addPackIssue, packIssue, PackValidationError } from "./errors.js";
+import { DEFAULT_NATIVE_SCALE } from "./defaults.js";
+import { parseDataText } from "./json.js";
+import { ASSET_PATH_PATTERN, NAME_PATTERN, SEMVER_PATTERN, SPDX_LICENSE_PATTERN, } from "./contracts.js";
+import { closed, record as object, validateDensityVariants, validateMotionKeyframes, validateSha256, validateStateMap, } from "./pack-shared.js";
+import { NATIVE_CELL_SIZE, NATIVE_COLUMNS, NATIVE_DENSITIES, NATIVE_DIRECTIONS, NATIVE_LOGICAL_SIZES, } from "./types.js";
+import { OwnDataError, snapshotPackData } from "./own-data.js";
+const MAX_ATLAS_BYTES = 4 * 1024 * 1024;
+export const MAX_ATLAS_SIDE = 4096;
+const MAX_STRING = 256;
+const METADATA_TAG_PATTERN = /^[a-z][a-z0-9._-]{0,63}$/;
+function safeString(value, field, issues, maximum = MAX_STRING) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > maximum) {
+        addPackIssue(issues, field, `${field} must be 1-${maximum} characters`);
+        return undefined;
+    }
+    if (/[\u0000-\u001f\u007f]/.test(value)) {
+        addPackIssue(issues, field, `${field} contains control characters`);
+        return undefined;
+    }
+    return value;
+}
+export function parseManifestText(text) {
+    return parseDataText(text, "character.json");
+}
+export function validateNativePack(input, geometry, preferredDensity = 1) {
+    const issues = [];
+    try {
+        input = snapshotPackData(input);
+    }
+    catch (cause) {
+        if (cause instanceof OwnDataError) {
+            throw new PackValidationError([cause.message], cause.issueCode ? [cause.issueCode] : []);
+        }
+        throw cause;
+    }
+    if (!object(input))
+        throw new PackValidationError([
+            packIssue("manifest", "manifest must be an object"),
+        ]);
+    closed(input, [
+        "format",
+        "name",
+        "version",
+        "license",
+        "metadata",
+        "assets",
+        "states",
+        "capabilities",
+        "defaults",
+    ], "manifest", issues);
+    if (input.format !== 1)
+        addPackIssue(issues, "format", "format must be the integer 1");
+    const name = safeString(input.name, "name", issues, 64);
+    if (name && !NAME_PATTERN.test(name))
+        addPackIssue(issues, "name", "name must be a lowercase ID");
+    const version = safeString(input.version, "version", issues, 64);
+    const license = safeString(input.license, "license", issues, 128);
+    if (version && !SEMVER_PATTERN.test(version))
+        addPackIssue(issues, "version", "version must be SemVer 2.0");
+    if (license && !SPDX_LICENSE_PATTERN.test(license))
+        addPackIssue(issues, "license", "license must be SPDX or LicenseRef");
+    let atlasSrc;
+    let atlasSha256;
+    let rows = 0;
+    let density = 1;
+    let logicalCellSize = NATIVE_CELL_SIZE;
+    let sourceCellSize = NATIVE_CELL_SIZE;
+    let lineage;
+    let variants;
+    if (!object(input.assets)) {
+        addPackIssue(issues, "assets", "assets must describe an atlas or variants");
+    }
+    else if (object(input.assets.atlas)) {
+        closed(input.assets, ["atlas"], "assets", issues);
+        const atlas = input.assets.atlas;
+        closed(atlas, [
+            "src",
+            "columns",
+            "rows",
+            "density",
+            "logicalCellSize",
+            "sourceCellSize",
+            "sha256",
+        ], "assets.atlas", issues);
+        atlasSrc = safeString(atlas.src, "assets.atlas.src", issues);
+        if (validateSha256(atlas.sha256, "assets.atlas.sha256", issues)) {
+            atlasSha256 = atlas.sha256;
+        }
+        if (atlasSrc &&
+            (!ASSET_PATH_PATTERN.test(atlasSrc) || !/\.png$/i.test(atlasSrc))) {
+            addPackIssue(issues, "assets.atlas.src", "assets.atlas.src must be a relative in-pack PNG path");
+        }
+        if (atlas.columns !== NATIVE_COLUMNS) {
+            addPackIssue(issues, "assets.atlas.columns", `assets.atlas.columns must be ${NATIVE_COLUMNS}`);
+        }
+        const densityFields = [
+            atlas.density,
+            atlas.logicalCellSize,
+            atlas.sourceCellSize,
+        ];
+        const hasDensityFields = densityFields.some((value) => value !== undefined);
+        const hasAllDensityFields = densityFields.every((value) => value !== undefined);
+        if (hasDensityFields && !hasAllDensityFields) {
+            addPackIssue(issues, "assets.atlas.density", "assets.atlas density and sizes must appear together");
+        }
+        if (hasAllDensityFields) {
+            if (!NATIVE_DENSITIES.includes(atlas.density)) {
+                addPackIssue(issues, "assets.atlas.density", "assets.atlas.density must be 1, 2, or 4");
+            }
+            else {
+                density = atlas.density;
+            }
+            if (!NATIVE_LOGICAL_SIZES.includes(atlas.logicalCellSize)) {
+                addPackIssue(issues, "assets.atlas.logicalCellSize", "assets.atlas.logicalCellSize must be 32 or 64");
+            }
+            else {
+                logicalCellSize = atlas.logicalCellSize;
+            }
+            if (!Number.isInteger(atlas.sourceCellSize) ||
+                atlas.sourceCellSize !== logicalCellSize * density) {
+                addPackIssue(issues, "assets.atlas.sourceCellSize", "assets.atlas.sourceCellSize must equal logical size * density");
+            }
+            else {
+                sourceCellSize = atlas.sourceCellSize;
+            }
+        }
+        if (!Number.isInteger(atlas.rows) ||
+            atlas.rows < 2 ||
+            atlas.rows > MAX_ATLAS_SIDE / sourceCellSize) {
+            addPackIssue(issues, "assets.atlas.rows", `assets.atlas.rows exceeds ${MAX_ATLAS_SIDE}px at density ${density}`);
+        }
+        else {
+            rows = atlas.rows;
+        }
+    }
+    else if (object(input.assets.atlases)) {
+        closed(input.assets, ["atlases"], "assets", issues);
+        const set = input.assets.atlases;
+        closed(set, ["columns", "rows", "logicalCellSize", "lineage", "variants"], "assets.atlases", issues);
+        if (set.columns !== NATIVE_COLUMNS)
+            addPackIssue(issues, "assets.atlases.columns", `assets.atlases.columns must be ${NATIVE_COLUMNS}`);
+        if (!NATIVE_LOGICAL_SIZES.includes(set.logicalCellSize)) {
+            addPackIssue(issues, "assets.atlases.logicalCellSize", "assets.atlases.logicalCellSize must be 32 or 64");
+        }
+        else
+            logicalCellSize = set.logicalCellSize;
+        lineage = safeString(set.lineage, "assets.atlases.lineage", issues, 128);
+        if (!lineage || !/^[a-z0-9][a-z0-9._-]{2,127}$/.test(lineage))
+            addPackIssue(issues, "assets.atlases.lineage", "assets.atlases.lineage must be a safe ID");
+        variants = validateDensityVariants(set.variants, {
+            path: "assets.atlases.variants",
+            logicalWidth: logicalCellSize,
+            logicalHeight: logicalCellSize,
+            native: true,
+        }, issues);
+        const chosen = variants.length
+            ? selectNativeDensity(variants.map((item) => item.density), preferredDensity)
+            : undefined;
+        const selected = variants.find((item) => item.density === chosen);
+        if (selected) {
+            atlasSrc = selected.src;
+            atlasSha256 = selected.sha256;
+            density = selected.density;
+            sourceCellSize = selected.cellWidth;
+        }
+        if (!Number.isInteger(set.rows) ||
+            set.rows < 2 ||
+            set.rows > MAX_ATLAS_SIDE / sourceCellSize)
+            addPackIssue(issues, "assets.atlases.rows", `assets.atlases.rows exceeds ${MAX_ATLAS_SIDE}px`);
+        else
+            rows = set.rows;
+    }
+    else {
+        addPackIssue(issues, "assets", "assets must contain atlas or atlases");
+    }
+    const states = validateStateMap(input.states, rows * NATIVE_COLUMNS, issues);
+    const directionalStates = Object.create(null);
+    let locomotionMotion;
+    if (input.capabilities !== undefined) {
+        if (object(input.capabilities))
+            closed(input.capabilities, ["locomotion"], "capabilities", issues);
+        const locomotion = object(input.capabilities)
+            ? input.capabilities.locomotion
+            : undefined;
+        if (!object(locomotion) || !object(locomotion.directions)) {
+            addPackIssue(issues, "capabilities.locomotion.directions", "locomotion.directions must be an object");
+        }
+        else {
+            closed(locomotion, ["directions", "motion"], "capabilities.locomotion", issues);
+            closed(locomotion.directions, NATIVE_DIRECTIONS, "capabilities.locomotion.directions", issues);
+            for (const direction of NATIVE_DIRECTIONS) {
+                const target = locomotion.directions[direction];
+                if (typeof target !== "string" || !states[target])
+                    addPackIssue(issues, `capabilities.locomotion.directions.${direction}`, `capabilities.locomotion.directions.${direction} must name a valid state`);
+                else
+                    directionalStates[direction] = target;
+            }
+            if (locomotion.motion !== undefined) {
+                const keyframes = object(locomotion.motion)
+                    ? locomotion.motion.keyframes
+                    : undefined;
+                if (object(locomotion.motion)) {
+                    closed(locomotion.motion, ["keyframes"], "capabilities.locomotion.motion", issues);
+                }
+                const parsed = validateMotionKeyframes(keyframes, "capabilities.locomotion.motion.keyframes", issues);
+                if (Array.isArray(keyframes) && parsed.length === keyframes.length)
+                    locomotionMotion = parsed;
+            }
+        }
+    }
+    let scale = DEFAULT_NATIVE_SCALE;
+    if (input.defaults !== undefined) {
+        if (!object(input.defaults)) {
+            addPackIssue(issues, "defaults", "defaults must be an object");
+        }
+        else {
+            closed(input.defaults, ["scale"], "defaults", issues);
+            if (input.defaults.scale !== undefined) {
+                if (!Number.isInteger(input.defaults.scale) ||
+                    input.defaults.scale < 1 ||
+                    input.defaults.scale > 4) {
+                    addPackIssue(issues, "defaults.scale", "defaults.scale must be an integer from 1 through 4");
+                }
+                else {
+                    scale = input.defaults.scale;
+                }
+            }
+        }
+    }
+    if (!object(input.metadata)) {
+        addPackIssue(issues, "metadata", "metadata must be an object with a description");
+    }
+    else {
+        closed(input.metadata, ["title", "author", "description", "tags"], "metadata", issues);
+        safeString(input.metadata.description, "metadata.description", issues, 500);
+        if (typeof input.metadata.description === "string" &&
+            /:\/\//.test(input.metadata.description)) {
+            addPackIssue(issues, "metadata.description", "metadata.description must not contain a URL");
+        }
+        for (const key of ["title", "author"]) {
+            if (input.metadata[key] !== undefined) {
+                safeString(input.metadata[key], `metadata.${key}`, issues, 120);
+                if (typeof input.metadata[key] === "string" &&
+                    /:\/\//.test(input.metadata[key])) {
+                    addPackIssue(issues, `metadata.${key}`, `metadata.${key} must not contain a URL`);
+                }
+            }
+        }
+        if (input.metadata.tags !== undefined &&
+            (!Array.isArray(input.metadata.tags) ||
+                input.metadata.tags.length > 16 ||
+                input.metadata.tags.some((tag) => typeof tag !== "string" || !METADATA_TAG_PATTERN.test(tag)))) {
+            addPackIssue(issues, "metadata.tags", "metadata.tags allows 16 lowercase IDs");
+        }
+    }
+    if (geometry) {
+        const expectedWidth = NATIVE_COLUMNS * sourceCellSize;
+        const expectedHeight = rows * sourceCellSize;
+        if (geometry.width !== expectedWidth ||
+            geometry.height !== expectedHeight) {
+            addPackIssue(issues, "atlas.dimensions", `atlas must be exactly ${expectedWidth}x${expectedHeight}`);
+        }
+        if (geometry.width > MAX_ATLAS_SIDE ||
+            geometry.height > MAX_ATLAS_SIDE ||
+            (geometry.byteLength !== undefined &&
+                geometry.byteLength > MAX_ATLAS_BYTES)) {
+            addPackIssue(issues, "atlas.size", "atlas exceeds native resource limits");
+        }
+    }
+    if (issues.length ||
+        !name ||
+        !version ||
+        !license ||
+        !atlasSrc ||
+        !atlasSha256) {
+        throw new PackValidationError(issues.length
+            ? issues
+            : [packIssue("manifest.incomplete", "manifest is incomplete")]);
+    }
+    const manifest = input;
+    return {
+        name,
+        displayName: manifest.metadata.title ?? name,
+        version,
+        license,
+        atlas: {
+            src: atlasSrc,
+            sha256: atlasSha256,
+            columns: NATIVE_COLUMNS,
+            rows,
+            cellWidth: sourceCellSize,
+            cellHeight: sourceCellSize,
+            logicalWidth: logicalCellSize,
+            logicalHeight: logicalCellSize,
+            density: density,
+            ...(lineage ? { lineage } : {}),
+            ...(variants ? { variants } : {}),
+        },
+        states,
+        defaultScale: scale,
+        ...(Object.keys(directionalStates).length ? { directionalStates } : {}),
+        ...(locomotionMotion ? { locomotionMotion } : {}),
+        ...(manifest.metadata ? { source: { metadata: manifest.metadata } } : {}),
+    };
+}
+export function selectNativeDensity(available, required) {
+    const sorted = [...new Set(available)].sort((a, b) => a - b);
+    if (!sorted.length)
+        throw new PackValidationError([
+            packIssue("atlas.variants", "atlas variant set is empty"),
+        ]);
+    return (sorted.find((value) => value >= required) ?? sorted.at(-1));
+}

package/dist/peekling.css

@@ -0,0 +1 @@
+:host{all:initial!important;position:fixed!important;inset:0!important;pointer-events:none!important}:host([data-peekling-host][hidden]){display:none!important}:host([data-peekling-host]){z-index:2147483646!important;contain:strict!important;overflow:hidden!important}.sprite{display:block;position:absolute;background-repeat:no-repeat;transform-origin:0 0}:host([data-peekling-content]){z-index:2147483645!important;color:var(--peekling-surface-color, #262626)!important;font:500 14px/1.4 system-ui!important}.surface{position:absolute;box-sizing:border-box;width:min(var(--peekling-surface-width, 320px),calc(100vw - 16px));max-height:calc(100vh - 16px);overflow:auto;padding:var(--peekling-surface-padding, 12px 14px);border:1px solid var(--peekling-surface-border, #d9d9d3);border-radius:var(--peekling-surface-radius, 14px);background:var(--peekling-surface-background, #fafafa);pointer-events:auto}.title{display:block}.surface p{margin:0}.surface a{display:inline-flex;min-width:44px;min-height:44px;align-items:center;justify-content:center;margin-top:6px;color:var(--peekling-surface-link, #174f00)}.surface a:focus-visible{outline:3px solid;outline-offset:3px}:host([data-peekling-controls]){z-index:2147483647!important;color:#262626!important;font:600 14px/1.25 system-ui!important}.peekling-visibility-trigger{position:fixed;right:0;bottom:0;width:64px;height:64px;border:0;background:transparent;opacity:0;pointer-events:none}.peekling-visibility-trigger:focus-visible{opacity:1;outline:3px solid;background:#fafafa}.peekling-visibility-panel{position:fixed;right:16px;bottom:16px;box-sizing:border-box;width:min(272px,calc(100vw - 32px));padding:16px;border:1px solid #d9d9d3;border-radius:18px;background:#fafafa;pointer-events:auto}.peekling-visibility-panel h2{margin:0 0 12px}.peekling-visibility-option{display:block;width:100%;min-height:44px;padding:10px 12px;border:0;background:transparent;color:inherit;font:inherit}.peekling-visibility-option:hover,.peekling-visibility-option:focus-visible{outline:2px solid}

package/dist/peekling.css.sri

@@ -0,0 +1 @@
+sha256-w8BENjaJ/B1wtpk3iuh7jT++FlbT5+fx5BBlvePx1qo=