@tileflow/core 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/capture-scene-BK_0J2oR.d.ts

@@ -0,0 +1,161 @@
+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 & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    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>;
+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;
+
+export { type NormalizedTileflowCaptureScene as N, type TileflowCaptureScene as T, type TileflowCaptureApplicationTarget as a, type TileflowCaptureBoundsCamera as b, type TileflowCaptureCamera as c, type TileflowCaptureCenterCamera as d, type TileflowCaptureMapTarget as e, type TileflowCaptureTarget as f, type TileflowCaptureViewport as g, normalizeTileflowCaptureScene as h, tileflowCaptureBoundsCameraSchema as i, tileflowCaptureCameraSchema as j, tileflowCaptureCenterCameraSchema as k, tileflowCaptureIdSchema as l, tileflowCaptureMapTargetSchema as m, normalizeTileflowCaptureId as n, tileflowCaptureSceneLimits as o, tileflowCaptureSceneNameSchema as p, tileflowCaptureSceneSchema as q, tileflowCaptureSceneSchemaVersion as r, tileflowCaptureTargetSchema as s, tileflowCaptureApplicationTargetSchema as t, tileflowCaptureViewportSchema as u };

package/dist/capture.d.ts

@@ -0,0 +1,9 @@
+export { N as NormalizedTileflowCaptureScene, a as TileflowCaptureApplicationTarget, b as TileflowCaptureBoundsCamera, c as TileflowCaptureCamera, d as TileflowCaptureCenterCamera, e as TileflowCaptureMapTarget, T as TileflowCaptureScene, f as TileflowCaptureTarget, g as TileflowCaptureViewport, n as normalizeTileflowCaptureId, h as normalizeTileflowCaptureScene, t as tileflowCaptureApplicationTargetSchema, i as tileflowCaptureBoundsCameraSchema, j as tileflowCaptureCameraSchema, k as tileflowCaptureCenterCameraSchema, l as tileflowCaptureIdSchema, m as tileflowCaptureMapTargetSchema, o as tileflowCaptureSceneLimits, p as tileflowCaptureSceneNameSchema, q as tileflowCaptureSceneSchema, r as tileflowCaptureSceneSchemaVersion, s as tileflowCaptureTargetSchema, u as tileflowCaptureViewportSchema } from './capture-scene-BK_0J2oR.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 & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+
+export { tileflowPortableIdSchema, tileflowThemeNameSchema };

package/dist/capture.js

@@ -0,0 +1,206 @@
+// src/capture-scene.ts
+import { z as z2 } from "zod";
+
+// src/portable-identity.ts
+import { z } from "zod";
+
+// src/portable-identity-rules.ts
+var tileflowPortableIdMaximumLength = 64;
+var tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+function isTileflowThemeName(value) {
+  return isTileflowPortableId(value) && value !== "system";
+}
+
+// src/portable-identity.ts
+var tileflowPortableIdSchema = z.string().min(1).max(tileflowPortableIdMaximumLength).regex(tileflowPortableIdPattern, {
+  message: "Expected lowercase kebab-case beginning with a letter"
+}).refine(
+  (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+  "Expected a portable identifier that is not a reserved filename or prototype key"
+);
+var tileflowThemeNameSchema = tileflowPortableIdSchema.refine(
+  isTileflowThemeName,
+  "Expected a concrete theme name; system is browser-only"
+);
+
+// src/capture-scene.ts
+var tileflowCaptureSceneSchemaVersion = 1;
+var tileflowCaptureSceneLimits = Object.freeze({
+  applicationPathLength: 2048,
+  boundsPadding: { maximum: 1024, minimum: 0 },
+  captureIdLength: tileflowPortableIdMaximumLength,
+  maximumPhysicalPixels: 16777216,
+  pitch: { maximum: 85, minimum: 0 },
+  selectorLength: 256,
+  viewport: { maximum: 4096, minimum: 64 },
+  zoom: { maximum: 24, minimum: 0 }
+});
+var finiteLongitudeSchema = z2.number().finite().min(-180).max(180);
+var finiteLatitudeSchema = z2.number().finite().min(-90).max(90);
+var bearingSchema = z2.number().finite().min(-180).max(180).optional();
+var pitchSchema = z2.number().finite().min(tileflowCaptureSceneLimits.pitch.minimum).max(tileflowCaptureSceneLimits.pitch.maximum).optional();
+var tileflowCaptureCenterCameraSchema = z2.object({
+  type: z2.literal("center"),
+  center: z2.tuple([finiteLongitudeSchema, finiteLatitudeSchema]),
+  zoom: z2.number().finite().min(tileflowCaptureSceneLimits.zoom.minimum).max(tileflowCaptureSceneLimits.zoom.maximum),
+  bearing: bearingSchema,
+  pitch: pitchSchema
+}).strict();
+var tileflowCaptureBoundsCameraSchema = z2.object({
+  type: z2.literal("bounds"),
+  bounds: z2.tuple([
+    finiteLongitudeSchema,
+    finiteLatitudeSchema,
+    finiteLongitudeSchema,
+    finiteLatitudeSchema
+  ]),
+  padding: z2.number().finite().min(tileflowCaptureSceneLimits.boundsPadding.minimum).max(tileflowCaptureSceneLimits.boundsPadding.maximum).optional(),
+  bearing: bearingSchema,
+  pitch: pitchSchema
+}).strict().superRefine((camera, context) => {
+  const [west, south, east, north] = camera.bounds;
+  if (south >= north) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected south latitude to be less than north latitude",
+      path: ["bounds"]
+    });
+  }
+  if (west === east) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected west and east longitude to define a non-empty span",
+      path: ["bounds"]
+    });
+  }
+});
+var tileflowCaptureCameraSchema = z2.discriminatedUnion("type", [
+  tileflowCaptureCenterCameraSchema,
+  tileflowCaptureBoundsCameraSchema
+]);
+var tileflowCaptureViewportSchema = z2.object({
+  width: z2.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  height: z2.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  dpr: z2.union([z2.literal(1), z2.literal(2)]).optional()
+}).strict().superRefine((viewport, context) => {
+  const dpr = viewport.dpr ?? 1;
+  const physicalWidth = viewport.width * dpr;
+  const physicalHeight = viewport.height * dpr;
+  const physicalPixels = viewport.width * viewport.height * dpr * dpr;
+  if (physicalWidth > tileflowCaptureSceneLimits.viewport.maximum || physicalHeight > tileflowCaptureSceneLimits.viewport.maximum || physicalPixels > tileflowCaptureSceneLimits.maximumPhysicalPixels) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected physical width and height at most ${tileflowCaptureSceneLimits.viewport.maximum} pixels`,
+      path: ["dpr"]
+    });
+  }
+});
+var tileflowCaptureIdSchema = z2.string().min(1).max(tileflowCaptureSceneLimits.captureIdLength).regex(/^[A-Za-z0-9_-]+$/, {
+  message: "Expected letters, numbers, underscores, or hyphens"
+}).refine((name) => name !== "__proto__", {
+  message: "Expected an identifier that cannot mutate an object prototype"
+});
+var tileflowCaptureSceneNameSchema = tileflowPortableIdSchema;
+var applicationPathSchema = z2.string().min(1).max(tileflowCaptureSceneLimits.applicationPathLength).refine(isPortableApplicationPath, {
+  message: "Expected a root-relative application path without an origin, credentials, fragment, backslash, or control character"
+});
+var tileflowCaptureMapTargetSchema = z2.object({ kind: z2.literal("map") }).strict();
+var tileflowCaptureApplicationTargetSchema = z2.object({
+  kind: z2.literal("application"),
+  path: applicationPathSchema,
+  captureId: tileflowCaptureIdSchema.optional(),
+  selector: z2.string().trim().min(1).max(tileflowCaptureSceneLimits.selectorLength).optional(),
+  frame: z2.enum(["map", "viewport"]).optional()
+}).strict().superRefine((target, context) => {
+  if (target.captureId && target.selector) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected either captureId or selector, not both",
+      path: ["selector"]
+    });
+  }
+});
+var tileflowCaptureTargetSchema = z2.discriminatedUnion("kind", [
+  tileflowCaptureMapTargetSchema,
+  tileflowCaptureApplicationTargetSchema
+]);
+var tileflowCaptureSceneSchema = z2.object({
+  map: tileflowPortableIdSchema,
+  theme: tileflowThemeNameSchema,
+  camera: tileflowCaptureCameraSchema,
+  viewport: tileflowCaptureViewportSchema,
+  target: tileflowCaptureTargetSchema.optional()
+}).strict();
+function normalizeTileflowCaptureScene(input) {
+  const scene = tileflowCaptureSceneSchema.parse(input);
+  const camera = scene.camera.type === "center" ? {
+    type: scene.camera.type,
+    center: scene.camera.center,
+    zoom: scene.camera.zoom,
+    bearing: scene.camera.bearing ?? 0,
+    pitch: scene.camera.pitch ?? 0
+  } : {
+    type: scene.camera.type,
+    bounds: scene.camera.bounds,
+    padding: scene.camera.padding ?? 0,
+    bearing: scene.camera.bearing ?? 0,
+    pitch: scene.camera.pitch ?? 0
+  };
+  const target = scene.target ?? { kind: "map" };
+  return {
+    map: scene.map,
+    theme: scene.theme,
+    camera,
+    viewport: { ...scene.viewport, dpr: scene.viewport.dpr ?? 1 },
+    target: target.kind === "map" ? target : {
+      kind: target.kind,
+      path: target.path,
+      ...target.captureId ? { captureId: target.captureId } : {},
+      ...target.selector ? { selector: target.selector } : {},
+      frame: target.frame ?? "map"
+    }
+  };
+}
+function normalizeTileflowCaptureId(value) {
+  return value === void 0 ? void 0 : tileflowCaptureIdSchema.parse(value);
+}
+function isPortableApplicationPath(value) {
+  if (value !== value.trim() || !value.startsWith("/") || value.startsWith("//") || value.includes("#") || value.includes("\\") || hasControlCharacter(value)) {
+    return false;
+  }
+  try {
+    const base = new URL("http://tileflow.local");
+    const resolved = new URL(value, base);
+    return resolved.origin === base.origin && resolved.username === "" && resolved.password === "" && resolved.pathname.startsWith("/");
+  } catch {
+    return false;
+  }
+}
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+export {
+  normalizeTileflowCaptureId,
+  normalizeTileflowCaptureScene,
+  tileflowCaptureApplicationTargetSchema,
+  tileflowCaptureBoundsCameraSchema,
+  tileflowCaptureCameraSchema,
+  tileflowCaptureCenterCameraSchema,
+  tileflowCaptureIdSchema,
+  tileflowCaptureMapTargetSchema,
+  tileflowCaptureSceneLimits,
+  tileflowCaptureSceneNameSchema,
+  tileflowCaptureSceneSchema,
+  tileflowCaptureSceneSchemaVersion,
+  tileflowCaptureTargetSchema,
+  tileflowCaptureViewportSchema,
+  tileflowPortableIdSchema,
+  tileflowThemeNameSchema
+};