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

package/dist/capture.js

@@ -0,0 +1,510 @@
+// src/capture-scene.ts
+import { z as z3 } from "zod";
+
+// src/manifest-schema-classic.ts
+import { z as z2 } from "zod";
+
+// src/native-zod-object.ts
+import { z } from "zod";
+function strictNativeObject(shape) {
+  const object = new z.core.$ZodObject({
+    type: "object",
+    shape,
+    catchall: z.never()
+  });
+  return z.lazy(() => object);
+}
+
+// src/manifest-schema-classic.ts
+function classic(schema) {
+  return schema;
+}
+var classicManifestStringOperations = {
+  string: () => z2.string(),
+  minLength(schema, minimum) {
+    return schema.min(
+      minimum
+    );
+  },
+  maxLength(schema, maximum) {
+    return schema.max(
+      maximum
+    );
+  },
+  regex: (schema, pattern, message) => schema.regex(pattern, { message }),
+  refine: (schema, check, message) => classic(schema).refine(check, message)
+};
+var classicManifestSchemaOperations = {
+  ...classicManifestStringOperations,
+  number: (minimum, maximum) => z2.number().finite().min(minimum).max(maximum),
+  unknown: () => z2.unknown(),
+  optional: (schema) => classic(schema).optional(),
+  array: (schema) => z2.array(classic(schema)),
+  enum(values) {
+    return z2.enum(values);
+  },
+  literal: (value) => z2.literal(value),
+  union: (left, right) => z2.union([classic(left), classic(right)]),
+  tuplePair(left, right) {
+    return z2.tuple([classic(left), classic(right)]);
+  },
+  object(shape) {
+    return strictNativeObject(shape);
+  },
+  record(key, value) {
+    return z2.record(classic(key), classic(value));
+  },
+  superRefine: (schema, check) => classic(schema).superRefine(check),
+  pipe: (input, output) => classic(input).pipe(classic(output))
+};
+
+// 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-schema.ts
+function createPortableIdentitySchemas(operations) {
+  const bounded = operations.maxLength(
+    operations.minLength(operations.string(), 1),
+    tileflowPortableIdMaximumLength
+  );
+  const pattern = operations.regex(
+    bounded,
+    tileflowPortableIdPattern,
+    "Expected lowercase kebab-case beginning with a letter"
+  );
+  const tileflowPortableIdSchema2 = operations.refine(
+    pattern,
+    (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"
+  );
+  const tileflowThemeNameSchema2 = operations.refine(
+    tileflowPortableIdSchema2,
+    isTileflowThemeName,
+    "Expected a concrete theme name; system is browser-only"
+  );
+  return { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 };
+}
+
+// src/portable-identity.ts
+var schemas = createPortableIdentitySchemas(classicManifestStringOperations);
+var tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
+var tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
+
+// src/camera-limits.ts
+var tileflowMaxPitch = 85;
+
+// src/capture-scene.ts
+var tileflowCaptureSceneSchemaVersion = 1;
+var tileflowCaptureSceneLimits = Object.freeze({
+  applicationPathLength: 2048,
+  boundsPadding: { maximum: 1024, minimum: 0 },
+  captureIdLength: tileflowPortableIdMaximumLength,
+  maximumPhysicalPixels: 16777216,
+  pitch: { maximum: tileflowMaxPitch, minimum: 0 },
+  selectorLength: 256,
+  viewport: { maximum: 4096, minimum: 64 },
+  zoom: { maximum: 24, minimum: 0 }
+});
+var finiteLongitudeSchema = z3.number().finite().min(-180).max(180);
+var finiteLatitudeSchema = z3.number().finite().min(-90).max(90);
+var bearingSchema = z3.number().finite().min(-180).max(180).optional();
+var pitchSchema = z3.number().finite().min(tileflowCaptureSceneLimits.pitch.minimum).max(tileflowCaptureSceneLimits.pitch.maximum).optional();
+var tileflowCaptureCenterCameraSchema = z3.object({
+  type: z3.literal("center"),
+  center: z3.tuple([finiteLongitudeSchema, finiteLatitudeSchema]),
+  zoom: z3.number().finite().min(tileflowCaptureSceneLimits.zoom.minimum).max(tileflowCaptureSceneLimits.zoom.maximum),
+  bearing: bearingSchema,
+  pitch: pitchSchema
+}).strict();
+var tileflowCaptureBoundsCameraSchema = z3.object({
+  type: z3.literal("bounds"),
+  bounds: z3.tuple([
+    finiteLongitudeSchema,
+    finiteLatitudeSchema,
+    finiteLongitudeSchema,
+    finiteLatitudeSchema
+  ]),
+  padding: z3.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 = z3.discriminatedUnion("type", [
+  tileflowCaptureCenterCameraSchema,
+  tileflowCaptureBoundsCameraSchema
+]);
+var tileflowCaptureViewportSchema = z3.object({
+  width: z3.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  height: z3.number().int().min(tileflowCaptureSceneLimits.viewport.minimum).max(tileflowCaptureSceneLimits.viewport.maximum),
+  dpr: z3.union([z3.literal(1), z3.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 = z3.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 = z3.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 = z3.object({ kind: z3.literal("map") }).strict();
+var tileflowCaptureApplicationTargetSchema = z3.object({
+  kind: z3.literal("application"),
+  path: applicationPathSchema,
+  captureId: tileflowCaptureIdSchema.optional(),
+  selector: z3.string().trim().min(1).max(tileflowCaptureSceneLimits.selectorLength).optional(),
+  frame: z3.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 = z3.discriminatedUnion("kind", [
+  tileflowCaptureMapTargetSchema,
+  tileflowCaptureApplicationTargetSchema
+]);
+var tileflowCaptureSceneSchema = z3.object({
+  map: tileflowPortableIdSchema,
+  theme: tileflowThemeNameSchema,
+  camera: tileflowCaptureCameraSchema,
+  viewport: tileflowCaptureViewportSchema,
+  target: tileflowCaptureTargetSchema.optional()
+}).strict();
+function tileflowCaptureSceneFitIssue(scene) {
+  if (scene.camera.type !== "bounds" || scene.camera.padding === void 0) return void 0;
+  const room = Math.min(scene.viewport.width, scene.viewport.height);
+  if (scene.camera.padding * 2 < room) return void 0;
+  return {
+    message: `Expected bounds padding less than half the viewport's shorter side (${room / 2} pixels)`,
+    path: ["camera", "padding"]
+  };
+}
+function normalizeTileflowCaptureScene(input) {
+  const scene = tileflowCaptureSceneSchema.parse(input);
+  const fit = tileflowCaptureSceneFitIssue(scene);
+  if (fit) throw new RangeError(`${fit.path.join(".")}: ${fit.message}`);
+  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;
+}
+
+// src/capture-shot.ts
+import { z as z4 } from "zod";
+
+// src/capture-shot-motion.ts
+function tileflowShotStateAt(shot, at) {
+  const { keyframes } = shot;
+  const first = keyframes[0];
+  const last = keyframes.at(-1);
+  if (!first || !last || keyframes.length < 2)
+    throw new TypeError("A shot needs at least two keyframes.");
+  const time = Math.min(last.at, Math.max(first.at, Number.isFinite(at) ? at : first.at));
+  let segment = 0;
+  while (segment < keyframes.length - 2 && time > keyframes[segment + 1].at) segment += 1;
+  const from = keyframes[segment];
+  const to = keyframes[segment + 1];
+  const linear = Math.min(1, Math.max(0, (time - from.at) / (to.at - from.at)));
+  const t = shot.easing === "linear" ? linear : smoothstep(linear);
+  return {
+    at: time,
+    camera: interpolateCamera(cameraOf(from), cameraOf(to), t),
+    ...from.blend && to.blend ? { blendPosition: interpolateNumber(from.blend.position, to.blend.position, t) } : {}
+  };
+}
+function cameraOf({ camera }) {
+  return {
+    type: "center",
+    center: [camera.center[0], camera.center[1]],
+    zoom: camera.zoom,
+    bearing: camera.bearing ?? 0,
+    pitch: camera.pitch ?? 0
+  };
+}
+var maximumMercatorLatitude = 85.051129;
+function interpolateCamera(from, to, t) {
+  return {
+    type: "center",
+    center: interpolateCenter(from.center, to.center, t),
+    zoom: interpolateNumber(from.zoom, to.zoom, t),
+    bearing: interpolateBearing(from.bearing, to.bearing, t),
+    pitch: interpolateNumber(from.pitch, to.pitch, t)
+  };
+}
+function interpolateNumber(from, to, t) {
+  if (t <= 0 || from === to) return from;
+  if (t >= 1) return to;
+  return from + (to - from) * t;
+}
+function interpolateCenter(from, to, t) {
+  if (t <= 0 || from[0] === to[0] && from[1] === to[1]) return [from[0], from[1]];
+  if (t >= 1) return [to[0], to[1]];
+  const start = mercatorFromLngLat(from);
+  const end = mercatorFromLngLat(to);
+  let dx = end[0] - start[0];
+  if (dx > 0.5) dx -= 1;
+  else if (dx < -0.5) dx += 1;
+  return lngLatFromMercator([start[0] + dx * t, start[1] + (end[1] - start[1]) * t]);
+}
+function interpolateBearing(from, to, t) {
+  if (t <= 0 || from === to) return from;
+  if (t >= 1) return to;
+  const delta = ((to - from) % 360 + 540) % 360 - 180;
+  return wrapDegrees(from + delta * t);
+}
+function mercatorFromLngLat([longitude, latitude]) {
+  const clamped = Math.max(-maximumMercatorLatitude, Math.min(maximumMercatorLatitude, latitude));
+  return [
+    (180 + longitude) / 360,
+    (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + clamped * Math.PI / 360))) / 360
+  ];
+}
+function lngLatFromMercator([x, y]) {
+  const latitude = 360 / Math.PI * Math.atan(Math.exp((180 - y * 360) * Math.PI / 180)) - 90;
+  return [wrapDegrees(x * 360 - 180), latitude];
+}
+function wrapDegrees(value) {
+  if (value >= -180 && value <= 180) return value;
+  return ((value + 180) % 360 + 360) % 360 - 180;
+}
+function smoothstep(t) {
+  return t * t * (3 - 2 * t);
+}
+
+// src/capture-shot.ts
+var tileflowCaptureShotSchemaVersion = 1;
+var tileflowCaptureShotLimits = Object.freeze({
+  blendThemes: Object.freeze({ maximum: 8, minimum: 2 }),
+  defaultFps: 30,
+  durationMs: Object.freeze({ maximum: 6e4 }),
+  fps: Object.freeze([24, 25, 30, 50, 60]),
+  keyframes: Object.freeze({ maximum: 64, minimum: 2 }),
+  maximumFrames: 3600
+});
+var tileflowCaptureShotNameSchema = tileflowCaptureSceneNameSchema;
+var tileflowCaptureShotBlendSchema = z4.object({
+  themes: z4.array(tileflowThemeNameSchema).min(tileflowCaptureShotLimits.blendThemes.minimum).max(tileflowCaptureShotLimits.blendThemes.maximum),
+  position: z4.number().finite().min(0)
+}).strict().superRefine((blend, context) => {
+  if (new Set(blend.themes).size !== blend.themes.length) {
+    context.addIssue({ code: "custom", message: "Expected distinct themes", path: ["themes"] });
+  }
+  if (blend.position > blend.themes.length - 1) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected a position from 0 to ${blend.themes.length - 1}`,
+      path: ["position"]
+    });
+  }
+});
+var tileflowCaptureShotKeyframeSchema = z4.object({
+  at: z4.number().int().min(0).max(tileflowCaptureShotLimits.durationMs.maximum),
+  camera: tileflowCaptureCenterCameraSchema,
+  blend: tileflowCaptureShotBlendSchema.optional()
+}).strict();
+var tileflowCaptureShotFields = {
+  theme: tileflowThemeNameSchema,
+  viewport: tileflowCaptureViewportSchema,
+  fps: z4.literal(tileflowCaptureShotLimits.fps).optional(),
+  keyframes: z4.array(tileflowCaptureShotKeyframeSchema).min(tileflowCaptureShotLimits.keyframes.minimum).max(tileflowCaptureShotLimits.keyframes.maximum),
+  easing: z4.enum(["smooth", "linear"]).optional()
+};
+var tileflowCaptureShotSchema = z4.object({ map: tileflowPortableIdSchema, ...tileflowCaptureShotFields }).strict().superRefine(checkShotTiming);
+var tileflowMapShotSchema = z4.object(tileflowCaptureShotFields).strict().superRefine(checkShotTiming);
+function normalizeTileflowCaptureShot(input) {
+  const shot = tileflowCaptureShotSchema.parse(input);
+  return { map: shot.map, ...normalizeShotFields(shot) };
+}
+function tileflowCaptureShotFrameCount(shot) {
+  const fps = shot.fps ?? tileflowCaptureShotLimits.defaultFps;
+  const duration = shot.keyframes.at(-1)?.at ?? 0;
+  return Math.floor(duration * fps / 1e3 + 1e-9) + 1;
+}
+function tileflowCaptureShotFrames(shot) {
+  const { map: _map, ...fields } = shot;
+  const normalized = normalizeShotFields(tileflowMapShotSchema.parse(fields));
+  const count = tileflowCaptureShotFrameCount(normalized);
+  const duration = normalized.keyframes.at(-1).at;
+  const frames = [];
+  for (let index = 0; index < count; index += 1) {
+    const at = Math.min(duration, index * 1e3 / normalized.fps);
+    frames.push({ index, ...tileflowShotStateAt(normalized, at) });
+  }
+  return frames;
+}
+function normalizeShotFields(shot) {
+  return {
+    theme: shot.theme,
+    viewport: { ...shot.viewport, dpr: shot.viewport.dpr ?? 1 },
+    fps: shot.fps ?? tileflowCaptureShotLimits.defaultFps,
+    easing: shot.easing ?? "smooth",
+    keyframes: shot.keyframes.map((keyframe) => ({
+      at: keyframe.at,
+      camera: {
+        type: "center",
+        center: keyframe.camera.center,
+        zoom: keyframe.camera.zoom,
+        bearing: keyframe.camera.bearing ?? 0,
+        pitch: keyframe.camera.pitch ?? 0
+      },
+      ...keyframe.blend ? { blend: { themes: [...keyframe.blend.themes], position: keyframe.blend.position } } : {}
+    }))
+  };
+}
+function checkShotTiming(shot, context) {
+  const { keyframes } = shot;
+  if (keyframes[0] && keyframes[0].at !== 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected the first keyframe at 0 milliseconds",
+      path: ["keyframes", 0, "at"]
+    });
+  }
+  for (let index = 1; index < keyframes.length; index += 1) {
+    if (keyframes[index].at <= keyframes[index - 1].at) {
+      context.addIssue({
+        code: "custom",
+        message: "Expected a time after the previous keyframe",
+        path: ["keyframes", index, "at"]
+      });
+    }
+  }
+  const blended = keyframes.filter((keyframe) => keyframe.blend !== void 0);
+  if (blended.length > 0) {
+    const themes = JSON.stringify(blended[0].blend.themes);
+    keyframes.forEach((keyframe, index) => {
+      if (!keyframe.blend) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected a blend on every keyframe when one keyframe blends themes",
+          path: ["keyframes", index, "blend"]
+        });
+      } else if (JSON.stringify(keyframe.blend.themes) !== themes) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected the same themes, in the same order, on every keyframe",
+          path: ["keyframes", index, "blend", "themes"]
+        });
+      }
+    });
+  }
+  const frames = tileflowCaptureShotFrameCount(shot);
+  if (frames > tileflowCaptureShotLimits.maximumFrames) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected at most ${tileflowCaptureShotLimits.maximumFrames} frames; this shot renders ${frames}`,
+      path: ["keyframes", keyframes.length - 1, "at"]
+    });
+  }
+}
+export {
+  normalizeTileflowCaptureId,
+  normalizeTileflowCaptureScene,
+  normalizeTileflowCaptureShot,
+  tileflowCaptureApplicationTargetSchema,
+  tileflowCaptureBoundsCameraSchema,
+  tileflowCaptureCameraSchema,
+  tileflowCaptureCenterCameraSchema,
+  tileflowCaptureIdSchema,
+  tileflowCaptureMapTargetSchema,
+  tileflowCaptureSceneFitIssue,
+  tileflowCaptureSceneLimits,
+  tileflowCaptureSceneNameSchema,
+  tileflowCaptureSceneSchema,
+  tileflowCaptureSceneSchemaVersion,
+  tileflowCaptureShotBlendSchema,
+  tileflowCaptureShotFrameCount,
+  tileflowCaptureShotFrames,
+  tileflowCaptureShotKeyframeSchema,
+  tileflowCaptureShotLimits,
+  tileflowCaptureShotNameSchema,
+  tileflowCaptureShotSchema,
+  tileflowCaptureShotSchemaVersion,
+  tileflowCaptureTargetSchema,
+  tileflowCaptureViewportSchema,
+  tileflowPortableIdSchema,
+  tileflowThemeNameSchema
+};