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

package/dist/chunk-AQUGMUZW.js

@@ -0,0 +1,324 @@
+import {
+  isPathWithin
+} from "./chunk-D4OE4ITL.js";
+
+// src/config.ts
+import { createJiti } from "jiti";
+import { existsSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve, sep } from "path";
+import {
+  parseResolvedTileflowMap,
+  parseTileflowMap,
+  tileflowCaptureSceneNameSchema,
+  tileflowCaptureShotNameSchema,
+  TileflowResolvedMapValidationError
+} from "@tileflow/core";
+import { collectTileflowMapBuildLineage } from "@tileflow/core/build";
+var defaultTileflowApiUrl = "https://api.tileflow.dev";
+var defaultTileflowConfigPath = "tileflow.config.ts";
+var defaultTileflowManifestPath = "public/tileflow/manifest.json";
+var TileflowValidationError = class extends Error {
+  code = "CONFIG_INVALID";
+  messages;
+  phase = "config-validation";
+  constructor(messages) {
+    super("Invalid Tileflow config");
+    this.name = "TileflowValidationError";
+    this.messages = messages;
+  }
+};
+async function loadTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
+  return (await loadTileflowConfigWithInputs(configPath, options)).project;
+}
+async function loadTileflowConfigWithInputs(configPath = defaultTileflowConfigPath, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedPath = resolve(cwd, configPath);
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`Config not found: ${configPath}`);
+  }
+  if (options.fresh) {
+    clearTileflowLocalModuleCache(resolvedPath, cwd);
+  }
+  const jiti = createJiti(import.meta.url, {
+    fsCache: false,
+    moduleCache: true
+  });
+  const imported = await jiti.import(resolvedPath, { default: true });
+  const allowWorkspace = /\.workspace\.(?:[cm]?[jt]s)$/u.test(resolvedPath);
+  const project = asTileflowBuildCatalog(imported, { allowWorkspace });
+  return {
+    authoringMaps: getTileflowAuthoringMaps(imported, project, allowWorkspace),
+    configFile: resolvedPath,
+    inputFiles: collectTileflowConfigInputs(resolvedPath, cwd),
+    project
+  };
+}
+async function loadValidTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
+  const project = await loadTileflowConfig(configPath, options);
+  assertValidTileflowConfig(project);
+  return project;
+}
+async function loadValidTileflowConfigWithInputs(configPath = defaultTileflowConfigPath, options = {}) {
+  const loaded = await loadTileflowConfigWithInputs(configPath, options);
+  assertValidTileflowConfig(loaded.project);
+  return loaded;
+}
+function assertValidTileflowConfig(project) {
+  const messages = [];
+  for (const [mapId, map] of Object.entries(project.maps)) {
+    try {
+      parseResolvedTileflowMap(map);
+    } catch (error) {
+      messages.push({
+        level: "error",
+        path: `maps.${mapId}`,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const [sceneId, scene] of Object.entries(project.scenes ?? {})) {
+    if (!Object.hasOwn(project.maps, scene.map)) {
+      messages.push({
+        level: "error",
+        path: `scenes.${sceneId}.map`,
+        message: `Unknown Tileflow map "${scene.map}".`
+      });
+    }
+  }
+  for (const [shotId, shot] of Object.entries(project.shots ?? {})) {
+    if (!Object.hasOwn(project.maps, shot.map)) {
+      messages.push({
+        level: "error",
+        path: `shots.${shotId}.map`,
+        message: `Unknown Tileflow map "${shot.map}".`
+      });
+    }
+  }
+  if (messages.length > 0) throw new TileflowValidationError(messages);
+}
+function asTileflowBuildCatalog(input, options = {}) {
+  if (isRecord(input) && isRecord(input.maps)) {
+    if (!options.allowWorkspace) {
+      throw tileflowConfigValidationError(
+        "maps",
+        new Error(
+          "tileflow.config.ts must export one map. Multi-map catalogs are internal workspaces and must use a *.workspace.ts file."
+        )
+      );
+    }
+    const unknownKey = Object.keys(input).find((key) => key !== "maps");
+    if (unknownKey) {
+      throw tileflowConfigValidationError(
+        unknownKey,
+        new Error(`Tileflow workspace has unrecognized key "${unknownKey}".`)
+      );
+    }
+    const entries = Object.entries(input.maps).map(([key, value]) => {
+      const map2 = value;
+      const resolved2 = parseTileflowCatalogMap(map2, `maps.${key}`);
+      if (key !== resolved2.id) {
+        throw tileflowConfigValidationError(
+          `maps.${key}`,
+          new Error(`Tileflow workspace map key "${key}" must match the map id "${resolved2.id}".`)
+        );
+      }
+      return [
+        key,
+        resolved2,
+        collectTileflowMapBuildLineage(map2),
+        normalizeSingularMapScenes(map2, resolved2.id),
+        normalizeSingularMapShots(map2, resolved2.id)
+      ];
+    });
+    if (entries.length === 0) {
+      throw tileflowConfigValidationError(
+        "maps",
+        new Error("Tileflow workspace must contain at least one map.")
+      );
+    }
+    const scenes2 = /* @__PURE__ */ new Map();
+    for (const [mapId, , , mapScenes] of entries) {
+      for (const [sceneId, scene] of Object.entries(mapScenes ?? {})) {
+        if (scenes2.has(sceneId)) {
+          throw tileflowConfigValidationError(
+            `maps.${mapId}.scenes.${sceneId}`,
+            new Error(`Tileflow workspace scene "${sceneId}" is already defined by another map.`)
+          );
+        }
+        scenes2.set(sceneId, scene);
+      }
+    }
+    const shots2 = /* @__PURE__ */ new Map();
+    for (const [mapId, , , , mapShots] of entries) {
+      for (const [shotId, shot] of Object.entries(mapShots ?? {})) {
+        if (shots2.has(shotId)) {
+          throw tileflowConfigValidationError(
+            `maps.${mapId}.shots.${shotId}`,
+            new Error(`Tileflow workspace shot "${shotId}" is already defined by another map.`)
+          );
+        }
+        shots2.set(shotId, shot);
+      }
+    }
+    return {
+      mapMetadata: Object.fromEntries(
+        entries.map(([id, map2, lineage]) => [id, { id, lineage, version: map2.version }])
+      ),
+      maps: Object.fromEntries(entries.map(([id, map2]) => [id, map2])),
+      ...scenes2.size > 0 ? { scenes: Object.fromEntries(scenes2) } : {},
+      ...shots2.size > 0 ? { shots: Object.fromEntries(shots2) } : {}
+    };
+  }
+  const map = input;
+  const resolved = parseTileflowCatalogMap(map, "");
+  let scenes;
+  try {
+    scenes = normalizeSingularMapScenes(map, resolved.id);
+  } catch (error) {
+    throw tileflowConfigValidationError("scenes", error);
+  }
+  let shots;
+  try {
+    shots = normalizeSingularMapShots(map, resolved.id);
+  } catch (error) {
+    throw tileflowConfigValidationError("shots", error);
+  }
+  return {
+    mapMetadata: {
+      [resolved.id]: {
+        id: resolved.id,
+        lineage: collectTileflowMapBuildLineage(map),
+        version: resolved.version
+      }
+    },
+    maps: { [resolved.id]: resolved },
+    ...scenes ? { scenes } : {},
+    ...shots ? { shots } : {}
+  };
+}
+function parseTileflowCatalogMap(map, path) {
+  try {
+    return parseTileflowMap(map);
+  } catch (error) {
+    throw tileflowConfigValidationError(path, error);
+  }
+}
+function getTileflowAuthoringMaps(input, project, allowWorkspace) {
+  if (allowWorkspace && isRecord(input) && isRecord(input.maps)) {
+    const maps = input.maps;
+    return Object.fromEntries(
+      Object.keys(project.maps).map((mapId2) => [mapId2, maps[mapId2]])
+    );
+  }
+  const [mapId] = Object.keys(project.maps);
+  return mapId ? { [mapId]: input } : {};
+}
+function tileflowConfigValidationError(path, error) {
+  if (error instanceof TileflowValidationError) return error;
+  if (error instanceof TileflowResolvedMapValidationError) {
+    return new TileflowValidationError(
+      error.messages.map((message) => ({
+        ...message,
+        path: prefixValidationPath(path, message.path)
+      }))
+    );
+  }
+  return new TileflowValidationError([
+    {
+      level: "error",
+      path: path || "map",
+      message: error instanceof Error ? error.message : String(error)
+    }
+  ]);
+}
+function prefixValidationPath(prefix, path) {
+  const child = path === "config" ? "" : path;
+  if (!prefix) return child || "map";
+  return child ? `${prefix}.${child}` : prefix;
+}
+function normalizeSingularMapScenes(map, mapId) {
+  if (!map.scenes) return void 0;
+  return Object.fromEntries(
+    Object.entries(map.scenes).map(([sceneId, scene]) => {
+      const normalizedSceneId = tileflowCaptureSceneNameSchema.parse(sceneId);
+      return [normalizedSceneId, { ...scene, map: mapId }];
+    })
+  );
+}
+function normalizeSingularMapShots(map, mapId) {
+  if (!map.shots) return void 0;
+  return Object.fromEntries(
+    Object.entries(map.shots).map(([shotId, shot]) => {
+      const normalizedShotId = tileflowCaptureShotNameSchema.parse(shotId);
+      return [normalizedShotId, { ...shot, map: mapId }];
+    })
+  );
+}
+function getTileflowMapNames(project) {
+  return Object.keys(project.maps);
+}
+function getFirstTileflowMapName(project) {
+  const [mapName] = getTileflowMapNames(project);
+  if (!mapName) {
+    throw new Error("Tileflow config must define at least one map.");
+  }
+  return mapName;
+}
+var localRequire = createRequire(import.meta.url);
+function collectTileflowConfigInputs(configPath, cwd) {
+  const roots = [canonicalPath(cwd), canonicalPath(dirname(resolve(configPath)))];
+  const inputs = /* @__PURE__ */ new Set([canonicalPath(configPath)]);
+  const pending = [localRequire.cache[canonicalPath(configPath)]];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const module = pending.pop();
+    if (!module || visited.has(module.filename)) continue;
+    visited.add(module.filename);
+    const path = canonicalPath(module.filename);
+    if (!path.split(sep).includes("node_modules") && roots.some((root) => isPathWithin(root, path))) {
+      inputs.add(path);
+    }
+    pending.push(...module.children);
+  }
+  for (const cachePath of Object.keys(localRequire.cache)) {
+    const path = canonicalPath(cachePath);
+    if (!path.split(sep).includes("node_modules") && roots.some((root) => isPathWithin(root, path))) {
+      inputs.add(path);
+    }
+  }
+  return [...inputs].sort();
+}
+function clearTileflowLocalModuleCache(configPath, cwd) {
+  const roots = [canonicalPath(cwd), canonicalPath(dirname(resolve(configPath)))];
+  for (const cachePath of Object.keys(localRequire.cache)) {
+    if (cachePath.split(sep).includes("node_modules")) continue;
+    if (roots.some((root) => isPathWithin(root, canonicalPath(cachePath)))) {
+      delete localRequire.cache[cachePath];
+    }
+  }
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export {
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  TileflowValidationError,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs,
+  assertValidTileflowConfig,
+  getTileflowMapNames,
+  getFirstTileflowMapName
+};