@tileflow/core 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/capture-shot-ChPQvPyi.d.ts

@@ -0,0 +1,291 @@
+import { z } from 'zod';
+
+declare const tileflowCaptureSceneSchemaVersion: 1;
+declare const tileflowCaptureSceneLimits: Readonly<{
+    applicationPathLength: 2048;
+    boundsPadding: {
+        maximum: number;
+        minimum: number;
+    };
+    captureIdLength: 64;
+    maximumPhysicalPixels: 16777216;
+    pitch: {
+        maximum: number;
+        minimum: number;
+    };
+    selectorLength: 256;
+    viewport: {
+        maximum: number;
+        minimum: number;
+    };
+    zoom: {
+        maximum: number;
+        minimum: number;
+    };
+}>;
+declare const tileflowCaptureCenterCameraSchema: z.ZodObject<{
+    type: z.ZodLiteral<"center">;
+    center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zoom: z.ZodNumber;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const tileflowCaptureBoundsCameraSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bounds">;
+    bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const tileflowCaptureCameraSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"center">;
+    center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zoom: z.ZodNumber;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"bounds">;
+    bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "type">;
+declare const tileflowCaptureViewportSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    dpr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+}, z.core.$strict>;
+declare const tileflowCaptureIdSchema: z.ZodString;
+declare const tileflowCaptureSceneNameSchema: z.ZodString;
+declare const tileflowCaptureMapTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"map">;
+}, z.core.$strict>;
+declare const tileflowCaptureApplicationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"application">;
+    path: z.ZodString;
+    captureId: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    frame: z.ZodOptional<z.ZodEnum<{
+        map: "map";
+        viewport: "viewport";
+    }>>;
+}, z.core.$strict>;
+declare const tileflowCaptureTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"map">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"application">;
+    path: z.ZodString;
+    captureId: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    frame: z.ZodOptional<z.ZodEnum<{
+        map: "map";
+        viewport: "viewport";
+    }>>;
+}, z.core.$strict>], "kind">;
+declare const tileflowCaptureSceneSchema: z.ZodObject<{
+    map: z.ZodString;
+    theme: z.ZodString;
+    camera: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"center">;
+        center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        zoom: z.ZodNumber;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"bounds">;
+        bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        padding: z.ZodOptional<z.ZodNumber>;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "type">;
+    viewport: z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        dpr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strict>;
+    target: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"map">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"application">;
+        path: z.ZodString;
+        captureId: z.ZodOptional<z.ZodString>;
+        selector: z.ZodOptional<z.ZodString>;
+        frame: z.ZodOptional<z.ZodEnum<{
+            map: "map";
+            viewport: "viewport";
+        }>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+/**
+ * Why a scene's bounds padding leaves no room for its bounds, or undefined when it fits: padding on
+ * both sides must be less than the viewport's shorter side. MapLibre GL JS 6.11.2+ leaves a globe
+ * camera where it was when it cannot fit, so the capture would show the wrong view. Checked where
+ * scenes are validated rather than in the schema, so the published reference keeps its shape.
+ */
+declare function tileflowCaptureSceneFitIssue(scene: Pick<TileflowCaptureScene, 'camera' | 'viewport'>): {
+    message: string;
+    path: ['camera', 'padding'];
+} | undefined;
+type TileflowCaptureCenterCamera = z.infer<typeof tileflowCaptureCenterCameraSchema>;
+type TileflowCaptureBoundsCamera = z.infer<typeof tileflowCaptureBoundsCameraSchema>;
+type TileflowCaptureCamera = z.infer<typeof tileflowCaptureCameraSchema>;
+type TileflowCaptureViewport = z.infer<typeof tileflowCaptureViewportSchema>;
+type TileflowCaptureMapTarget = z.infer<typeof tileflowCaptureMapTargetSchema>;
+type TileflowCaptureApplicationTarget = z.infer<typeof tileflowCaptureApplicationTargetSchema>;
+type TileflowCaptureTarget = z.infer<typeof tileflowCaptureTargetSchema>;
+type TileflowCaptureScene = z.infer<typeof tileflowCaptureSceneSchema>;
+type NormalizedTileflowCaptureScene = {
+    map: string;
+    theme: string;
+    camera: {
+        type: 'center';
+        center: [number, number];
+        zoom: number;
+        bearing: number;
+        pitch: number;
+    } | {
+        type: 'bounds';
+        bounds: [number, number, number, number];
+        padding: number;
+        bearing: number;
+        pitch: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+        dpr: 1 | 2;
+    };
+    target: {
+        kind: 'map';
+    } | {
+        kind: 'application';
+        path: string;
+        captureId?: string;
+        selector?: string;
+        frame: 'map' | 'viewport';
+    };
+};
+declare function normalizeTileflowCaptureScene(input: TileflowCaptureScene): NormalizedTileflowCaptureScene;
+declare function normalizeTileflowCaptureId(value: string | undefined): string | undefined;
+
+/** A camera between keyframes: always the center form, with bearing and pitch resolved. */
+type TileflowShotCamera = {
+    type: 'center';
+    center: [number, number];
+    zoom: number;
+    bearing: number;
+    pitch: number;
+};
+
+declare const tileflowCaptureShotSchemaVersion: 1;
+declare const tileflowCaptureShotLimits: Readonly<{
+    blendThemes: Readonly<{
+        maximum: 8;
+        minimum: 2;
+    }>;
+    defaultFps: 30;
+    durationMs: Readonly<{
+        maximum: 60000;
+    }>;
+    fps: readonly [24, 25, 30, 50, 60];
+    keyframes: Readonly<{
+        maximum: 64;
+        minimum: 2;
+    }>;
+    maximumFrames: 3600;
+}>;
+/** Shot names follow the same portable artifact-name rules as scene names. */
+declare const tileflowCaptureShotNameSchema: z.ZodString;
+declare const tileflowCaptureShotBlendSchema: z.ZodObject<{
+    themes: z.ZodArray<z.ZodString>;
+    position: z.ZodNumber;
+}, z.core.$strict>;
+declare const tileflowCaptureShotKeyframeSchema: z.ZodObject<{
+    at: z.ZodNumber;
+    camera: z.ZodObject<{
+        type: z.ZodLiteral<"center">;
+        center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        zoom: z.ZodNumber;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    blend: z.ZodOptional<z.ZodObject<{
+        themes: z.ZodArray<z.ZodString>;
+        position: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const tileflowCaptureShotSchema: z.ZodObject<{
+    theme: z.ZodString;
+    viewport: z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        dpr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strict>;
+    fps: z.ZodOptional<z.ZodLiteral<24 | 25 | 30 | 50 | 60>>;
+    keyframes: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        camera: z.ZodObject<{
+            type: z.ZodLiteral<"center">;
+            center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            zoom: z.ZodNumber;
+            bearing: z.ZodOptional<z.ZodNumber>;
+            pitch: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        blend: z.ZodOptional<z.ZodObject<{
+            themes: z.ZodArray<z.ZodString>;
+            position: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    easing: z.ZodOptional<z.ZodEnum<{
+        linear: "linear";
+        smooth: "smooth";
+    }>>;
+    map: z.ZodString;
+}, z.core.$strict>;
+type TileflowCaptureShotBlend = z.infer<typeof tileflowCaptureShotBlendSchema>;
+type TileflowCaptureShotKeyframe = z.infer<typeof tileflowCaptureShotKeyframeSchema>;
+type TileflowCaptureShot = z.infer<typeof tileflowCaptureShotSchema>;
+type TileflowCaptureShotEasing = 'linear' | 'smooth';
+type NormalizedTileflowCaptureShotCamera = TileflowShotCamera;
+type NormalizedTileflowCaptureShot = {
+    map: string;
+    theme: string;
+    viewport: {
+        width: number;
+        height: number;
+        dpr: 1 | 2;
+    };
+    fps: 24 | 25 | 30 | 50 | 60;
+    easing: TileflowCaptureShotEasing;
+    keyframes: Array<{
+        at: number;
+        camera: NormalizedTileflowCaptureShotCamera;
+        blend?: {
+            themes: string[];
+            position: number;
+        };
+    }>;
+};
+/** One rendered frame of a shot: the camera and blend position at `at` milliseconds. */
+type TileflowCaptureShotFrame = {
+    index: number;
+    at: number;
+    camera: NormalizedTileflowCaptureShotCamera;
+    /** Present when the shot blends themes. */
+    blendPosition?: number;
+};
+declare function normalizeTileflowCaptureShot(input: TileflowCaptureShot): NormalizedTileflowCaptureShot;
+/**
+ * The number of frames a shot renders: one at the start and one every `1 / fps` seconds up to its
+ * last keyframe. The last keyframe is a frame when its time is a whole number of frame intervals.
+ */
+declare function tileflowCaptureShotFrameCount(shot: Pick<TileflowCaptureShot, 'fps' | 'keyframes'>): number;
+/**
+ * Interpolates every frame of a shot. Frame `i` shows the shot at `i * 1000 / fps` milliseconds.
+ * Within each keyframe segment the center moves in Web Mercator coordinates along the shorter way
+ * around the world, zoom and pitch change linearly, bearing turns along the shorter arc, and the
+ * blend position changes linearly; `easing: 'smooth'` eases each segment in and out.
+ */
+declare function tileflowCaptureShotFrames(shot: TileflowCaptureShot | Omit<TileflowCaptureShot, 'map'>): TileflowCaptureShotFrame[];
+
+export { tileflowCaptureSceneSchemaVersion as A, tileflowCaptureShotBlendSchema as B, tileflowCaptureShotFrameCount as C, tileflowCaptureShotFrames as D, tileflowCaptureShotKeyframeSchema as E, tileflowCaptureShotLimits as F, tileflowCaptureShotNameSchema as G, tileflowCaptureShotSchema as H, tileflowCaptureShotSchemaVersion as I, tileflowCaptureTargetSchema as J, tileflowCaptureViewportSchema as K, tileflowCaptureSceneFitIssue as L, type NormalizedTileflowCaptureScene as N, type TileflowCaptureScene as T, type TileflowCaptureShot as a, type NormalizedTileflowCaptureShot as b, type NormalizedTileflowCaptureShotCamera as c, type TileflowCaptureApplicationTarget as d, type TileflowCaptureBoundsCamera as e, type TileflowCaptureCamera as f, type TileflowCaptureCenterCamera as g, type TileflowCaptureMapTarget as h, type TileflowCaptureShotBlend as i, type TileflowCaptureShotEasing as j, type TileflowCaptureShotFrame as k, type TileflowCaptureShotKeyframe as l, type TileflowCaptureTarget as m, type TileflowCaptureViewport as n, normalizeTileflowCaptureId as o, normalizeTileflowCaptureScene as p, normalizeTileflowCaptureShot as q, tileflowCaptureBoundsCameraSchema as r, tileflowCaptureCameraSchema as s, tileflowCaptureApplicationTargetSchema as t, tileflowCaptureCenterCameraSchema as u, tileflowCaptureIdSchema as v, tileflowCaptureMapTargetSchema as w, tileflowCaptureSceneLimits as x, tileflowCaptureSceneNameSchema as y, tileflowCaptureSceneSchema as z };

package/dist/capture.d.ts

@@ -0,0 +1,9 @@
+export { N as NormalizedTileflowCaptureScene, b as NormalizedTileflowCaptureShot, c as NormalizedTileflowCaptureShotCamera, d as TileflowCaptureApplicationTarget, e as TileflowCaptureBoundsCamera, f as TileflowCaptureCamera, g as TileflowCaptureCenterCamera, h as TileflowCaptureMapTarget, T as TileflowCaptureScene, a as TileflowCaptureShot, i as TileflowCaptureShotBlend, j as TileflowCaptureShotEasing, k as TileflowCaptureShotFrame, l as TileflowCaptureShotKeyframe, m as TileflowCaptureTarget, n as TileflowCaptureViewport, o as normalizeTileflowCaptureId, p as normalizeTileflowCaptureScene, q as normalizeTileflowCaptureShot, t as tileflowCaptureApplicationTargetSchema, r as tileflowCaptureBoundsCameraSchema, s as tileflowCaptureCameraSchema, u as tileflowCaptureCenterCameraSchema, v as tileflowCaptureIdSchema, w as tileflowCaptureMapTargetSchema, L as tileflowCaptureSceneFitIssue, x as tileflowCaptureSceneLimits, y as tileflowCaptureSceneNameSchema, z as tileflowCaptureSceneSchema, A as tileflowCaptureSceneSchemaVersion, B as tileflowCaptureShotBlendSchema, C as tileflowCaptureShotFrameCount, D as tileflowCaptureShotFrames, E as tileflowCaptureShotKeyframeSchema, F as tileflowCaptureShotLimits, G as tileflowCaptureShotNameSchema, H as tileflowCaptureShotSchema, I as tileflowCaptureShotSchemaVersion, J as tileflowCaptureTargetSchema, K as tileflowCaptureViewportSchema } from './capture-shot-ChPQvPyi.js';
+import { z } from 'zod';
+
+/** Canonical, filesystem-safe identity shared by authored and emitted Tileflow resources. */
+declare const tileflowPortableIdSchema: z.ZodString;
+/** A concrete compiled theme identity. `system` exists only as a browser-side selector. */
+declare const tileflowThemeNameSchema: z.ZodString;
+
+export { tileflowPortableIdSchema, tileflowThemeNameSchema };