@tileflow/dev 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import { TileflowMap, ValidationMessage } from '@tileflow/core';
+import { TileflowBuildCatalog } from '@tileflow/core/build';
+
+declare const defaultTileflowApiUrl = "https://api.tileflow.dev";
+declare const defaultTileflowConfigPath = "tileflow.config.ts";
+declare const defaultTileflowManifestPath = "public/tileflow/manifest.json";
+type LoadTileflowConfigOptions = {
+    cwd?: string;
+    fresh?: boolean;
+};
+type LoadedTileflowConfig = {
+    /** Tooling-only authoring definitions retained for resolved-config provenance. Never serialize. */
+    authoringMaps: Record<string, TileflowMap>;
+    /** Absolute executable config path. Asset directories resolve from its parent directory. */
+    configFile: string;
+    inputFiles: string[];
+    project: TileflowBuildCatalog;
+};
+declare class TileflowValidationError extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly messages: ValidationMessage[];
+    readonly phase: "config-validation";
+    constructor(messages: ValidationMessage[]);
+}
+declare function loadTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowBuildCatalog>;
+declare function loadTileflowConfigWithInputs(configPath?: string, options?: LoadTileflowConfigOptions): Promise<LoadedTileflowConfig>;
+declare function loadValidTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowBuildCatalog>;
+declare function loadValidTileflowConfigWithInputs(configPath?: string, options?: LoadTileflowConfigOptions): Promise<LoadedTileflowConfig>;
+declare function assertValidTileflowConfig(project: TileflowBuildCatalog): void;
+declare function getTileflowMapNames(project: TileflowBuildCatalog): string[];
+declare function getFirstTileflowMapName(project: TileflowBuildCatalog): string;
+
+export { type LoadTileflowConfigOptions, type LoadedTileflowConfig, TileflowValidationError, assertValidTileflowConfig, defaultTileflowApiUrl, defaultTileflowConfigPath, defaultTileflowManifestPath, getFirstTileflowMapName, getTileflowMapNames, loadTileflowConfig, loadTileflowConfigWithInputs, loadValidTileflowConfig, loadValidTileflowConfigWithInputs };

package/dist/config.js

@@ -0,0 +1,27 @@
+import {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-6MGFMKG3.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+};

package/dist/fonts.d.ts

@@ -0,0 +1,47 @@
+import { TileflowFontBundleManifest, MapLibreStyle } from '@tileflow/core';
+import { TileflowEffectiveFontSourceIdentity, TileflowBuildStyles, TileflowBuildCatalog } from '@tileflow/core/build';
+import { TileflowBuildAsset } from './icons.js';
+
+type TileflowFontCompilationTarget = 'hosted' | 'local';
+type TileflowFontCompilationIssue = {
+    message: string;
+    path: string;
+};
+declare class TileflowFontCompilationError extends Error {
+    readonly code: "FONT_INVALID";
+    readonly issues: readonly TileflowFontCompilationIssue[];
+    readonly phase: "font-compilation";
+    constructor(issues: readonly TileflowFontCompilationIssue[]);
+}
+type PreparedTileflowStyleFonts = {
+    assets: TileflowBuildAsset[];
+    bundles: Record<string, CompiledTileflowFontBundle>;
+    sourceIdentities: Record<string, TileflowEffectiveFontSourceIdentity[]>;
+    styles: TileflowBuildStyles;
+    watchPaths: string[];
+};
+type CompiledTileflowFontBundle = {
+    contentHash: string;
+    files: TileflowBuildAsset[];
+    manifest: TileflowFontBundleManifest;
+};
+type PrepareTileflowStyleFontsOptions = {
+    assetBaseUrl: string;
+    baseDirectory?: string;
+    cwd: string;
+    target: TileflowFontCompilationTarget;
+};
+/** Resolve only mutable local font directories so failed builds can still be watched. */
+declare function getTileflowFontWatchPaths(project: TileflowBuildCatalog, cwd: string, baseDirectory?: string): Promise<string[]>;
+/**
+ * Prepare every map's ordered local font provider.
+ *
+ * OpenType full names are the canonical IDs consumed by `text-font`. Directories are applied from
+ * left to right, so a later directory replaces an earlier face only when that exact ID matches.
+ */
+declare function prepareTileflowStyleFonts(project: TileflowBuildCatalog, inputStyles: Readonly<Record<string, Readonly<Record<string, MapLibreStyle>>>>, options: PrepareTileflowStyleFontsOptions): Promise<PreparedTileflowStyleFonts>;
+/** Replace provisional local/preflight URLs with one exact Hosted bundle base URL. */
+declare function bindTileflowStyleFontBundle(style: MapLibreStyle, bundle: CompiledTileflowFontBundle, publicBaseUrl: string): MapLibreStyle;
+declare function replaceTileflowStyleFontSources(style: MapLibreStyle, replace: (source: string) => string): MapLibreStyle;
+
+export { type CompiledTileflowFontBundle, type PrepareTileflowStyleFontsOptions, type PreparedTileflowStyleFonts, TileflowFontCompilationError, type TileflowFontCompilationIssue, type TileflowFontCompilationTarget, bindTileflowStyleFontBundle, getTileflowFontWatchPaths, prepareTileflowStyleFonts, replaceTileflowStyleFontSources };

package/dist/fonts.js

@@ -0,0 +1,16 @@
+import {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+} from "./chunk-RSBV4L2Y.js";
+import "./chunk-BL3FK4GO.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+};

package/dist/icons.d.ts

@@ -0,0 +1,136 @@
+import { TileflowIconPackageFileName, TileflowIconPackageManifest } from '@tileflow/core';
+import { TileflowBuildCatalog, TileflowPreparedMapAssets, TileflowEffectiveIconSourceIdentity } from '@tileflow/core/build';
+
+type TileflowBuildAsset = {
+    contentType: string;
+    fileName: string;
+    source: string | Uint8Array;
+};
+/** Executable authoring input before local sources have been resolved into runtime URLs. */
+type TileflowSourceCatalog = TileflowBuildCatalog;
+declare const preparedTileflowBuildCatalog: unique symbol;
+/** A validated catalog paired with build-owned portable assets. */
+type PreparedTileflowBuildCatalog = TileflowBuildCatalog & {
+    readonly [preparedTileflowBuildCatalog]: true;
+};
+type PreparedTileflowCatalog = {
+    assets: TileflowBuildAsset[];
+    baseDirectory: string;
+    cwd: string;
+    mapAssets: Record<string, TileflowPreparedMapAssets>;
+    mapIconSources: Record<string, readonly TileflowEffectiveIconSourceIdentity[]>;
+    project: PreparedTileflowBuildCatalog;
+    sourceProject: TileflowSourceCatalog;
+    watchPaths: string[];
+};
+type TileflowIconCompilationTarget = 'hosted' | 'local';
+type TileflowIconCompilationIssue = {
+    message: string;
+    path: string;
+};
+type CompiledTileflowIconPackageFile = {
+    contentType: 'application/json' | 'image/png';
+    fileName: TileflowIconPackageFileName;
+    source: Uint8Array;
+};
+type CompiledTileflowIconPackage = {
+    contentHash: string;
+    files: CompiledTileflowIconPackageFile[];
+    manifest: TileflowIconPackageManifest;
+};
+type TileflowMapIconPackageBinding = {
+    iconIds: readonly string[];
+    label: string;
+    mapName: string;
+    packageHash: string;
+};
+type CompileTileflowIconPackagesResult = {
+    bindings: TileflowMapIconPackageBinding[];
+    packages: CompiledTileflowIconPackage[];
+    sourceIdentities: Record<string, readonly TileflowEffectiveIconSourceIdentity[]>;
+    watchPaths: string[];
+};
+type InspectTileflowIconCatalogsOptions = {
+    baseDirectory?: string;
+    cwd: string;
+    mapNames?: readonly string[];
+};
+type TileflowIconCatalogSourceFormat = 'jpeg' | 'png' | 'svg' | 'webp';
+type TileflowIconCatalogAtlasRectangle = {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};
+type TileflowIconCatalogRenderedDensity = {
+    atlas: TileflowIconCatalogAtlasRectangle;
+    height: number;
+    pixelRatio: 1 | 2;
+    pixelSha256: string;
+    width: number;
+};
+type TileflowIconCatalogIcon = {
+    id: string;
+    rendered: {
+        oneX: TileflowIconCatalogRenderedDensity;
+        twoX: TileflowIconCatalogRenderedDensity;
+    };
+    source: {
+        byteLength: number;
+        dimensions: {
+            height: number;
+            width: number;
+        } | null;
+        format: TileflowIconCatalogSourceFormat;
+        path: string;
+    };
+};
+type TileflowIconCatalog = {
+    compiledPackage: CompiledTileflowIconPackage;
+    directories: string[];
+    icons: TileflowIconCatalogIcon[];
+    insideWorkingTree: boolean;
+    replacements: TileflowIconReplacement[];
+};
+type TileflowIconReplacement = {
+    id: string;
+    replaced: string;
+    winner: string;
+};
+type TileflowIconCatalogMap = {
+    name: string;
+    icons: {
+        directories: string[];
+        iconIds: string[];
+        kind: 'directories';
+        label: string;
+        packageHash: string;
+    } | {
+        kind: 'none';
+    };
+};
+type TileflowIconCatalogInspection = {
+    catalogs: TileflowIconCatalog[];
+    maps: TileflowIconCatalogMap[];
+};
+declare class TileflowIconCompilationError extends Error {
+    readonly code: "ICON_INVALID";
+    readonly issues: TileflowIconCompilationIssue[];
+    readonly phase: "icon-compilation";
+    constructor(issues: TileflowIconCompilationIssue[]);
+}
+declare const iconFileExtensions: Set<string>;
+declare function compileTileflowIconPackages(project: TileflowBuildCatalog, options: {
+    baseDirectory?: string;
+    cwd: string;
+    target: TileflowIconCompilationTarget;
+}): Promise<CompileTileflowIconPackagesResult>;
+declare function inspectTileflowIconCatalogs(project: TileflowBuildCatalog, options: InspectTileflowIconCatalogsOptions): Promise<TileflowIconCatalogInspection>;
+declare function prepareTileflowCatalogIcons(project: TileflowBuildCatalog, options: {
+    assetBaseUrl: string;
+    baseDirectory?: string;
+    cwd: string;
+}): Promise<PreparedTileflowCatalog>;
+declare function getTileflowIconWatchPaths(project: TileflowBuildCatalog, cwd: string, baseDirectory?: string): Promise<string[]>;
+
+export { type CompileTileflowIconPackagesResult, type CompiledTileflowIconPackage, type CompiledTileflowIconPackageFile, type InspectTileflowIconCatalogsOptions, type PreparedTileflowBuildCatalog, type PreparedTileflowCatalog, type TileflowBuildAsset, type TileflowIconCatalog, type TileflowIconCatalogAtlasRectangle, type TileflowIconCatalogIcon, type TileflowIconCatalogInspection, type TileflowIconCatalogMap, type TileflowIconCatalogRenderedDensity, type TileflowIconCatalogSourceFormat, TileflowIconCompilationError, type TileflowIconCompilationIssue, type TileflowIconCompilationTarget, type TileflowIconReplacement, type TileflowMapIconPackageBinding, type TileflowSourceCatalog, compileTileflowIconPackages, getTileflowIconWatchPaths, iconFileExtensions, inspectTileflowIconCatalogs, prepareTileflowCatalogIcons };

package/dist/icons.js

@@ -0,0 +1,17 @@
+import {
+  TileflowIconCompilationError,
+  compileTileflowIconPackages,
+  getTileflowIconWatchPaths,
+  iconFileExtensions,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons
+} from "./chunk-CENQR5Q2.js";
+import "./chunk-BL3FK4GO.js";
+export {
+  TileflowIconCompilationError,
+  compileTileflowIconPackages,
+  getTileflowIconWatchPaths,
+  iconFileExtensions,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons
+};

package/dist/index.d.ts

@@ -1,54 +1,13 @@
-import { TileflowManifest, MapLibreStyle, ValidationMessage, TileflowProjectConfig, TileflowStyleOptions } from '@tileflow/core';
-
-declare const defaultTileflowApiUrl = "https://api.tileflow.dev";
-declare const defaultTileflowConfigPath = "tileflow.config.ts";
-declare const defaultTileflowManifestPath = "public/tileflow/manifest.json";
-declare const defaultTileflowTileset = "world";
-type LoadTileflowConfigOptions = {
-    cwd?: string;
-    fresh?: boolean;
-};
-type TileflowManifestOptions = {
-    styleBaseUrl?: string;
-    tileBaseUrl?: string;
-};
-type TileflowDevRequestHandlerOptions = {
-    basePath?: string;
-    config?: string;
-    cwd?: string;
-    onError?: (error: unknown) => void;
-    styleBaseUrl?: string;
-    tileBaseUrl?: string;
-};
-type TileflowBuildArtifactsOptions = {
-    config?: string;
-    cwd?: string;
-    styleBaseUrl?: string;
-    tileBaseUrl?: string;
-};
-type TileflowBuildArtifacts = {
-    manifest: TileflowManifest;
-    styles: Record<string, MapLibreStyle>;
-};
-type WriteTileflowBuildArtifactsOptions = TileflowBuildArtifactsOptions & {
-    outDir: string;
-};
-declare class TileflowValidationError extends Error {
-    readonly messages: ValidationMessage[];
-    constructor(messages: ValidationMessage[]);
-}
-declare function loadTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowProjectConfig>;
-declare function loadValidTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowProjectConfig>;
-declare function assertValidTileflowConfig(project: TileflowProjectConfig): void;
-declare function asTileflowProjectConfig(input: unknown): TileflowProjectConfig;
-declare function getTileflowMapNames(project: TileflowProjectConfig): string[];
-declare function getFirstTileflowMapName(project: TileflowProjectConfig): string;
-declare function getTileflowStyleMapName(path: string): string;
-declare function createTileflowManifest(project: TileflowProjectConfig, options?: TileflowManifestOptions): TileflowManifest;
-declare function createTileflowStyle(project: TileflowProjectConfig, mapName: string, options?: TileflowStyleOptions): MapLibreStyle;
-declare function createTileflowBuildArtifacts(options?: TileflowBuildArtifactsOptions): Promise<TileflowBuildArtifacts>;
-declare function writeTileflowBuildArtifacts(options: WriteTileflowBuildArtifactsOptions): Promise<TileflowBuildArtifacts>;
-declare function createTileflowDevRequestHandler(options?: TileflowDevRequestHandlerOptions): (request: Request) => Promise<Response>;
-declare function normalizeTileflowBasePath(value?: string): string;
-
-export { type LoadTileflowConfigOptions, type TileflowBuildArtifacts, type TileflowBuildArtifactsOptions, type TileflowDevRequestHandlerOptions, type TileflowManifestOptions, TileflowValidationError, type WriteTileflowBuildArtifactsOptions, asTileflowProjectConfig, assertValidTileflowConfig, createTileflowBuildArtifacts, createTileflowDevRequestHandler, createTileflowManifest, createTileflowStyle, defaultTileflowApiUrl, defaultTileflowConfigPath, defaultTileflowManifestPath, defaultTileflowTileset, getFirstTileflowMapName, getTileflowMapNames, getTileflowStyleMapName, loadTileflowConfig, loadValidTileflowConfig, normalizeTileflowBasePath, writeTileflowBuildArtifacts };
+export { CreateTileflowArtifactPlanOptions, TileflowArtifactAcquisition, TileflowArtifactDiagnostic, TileflowArtifactFile, TileflowArtifactInputGraph, TileflowArtifactPlan, TileflowArtifactSession, TileflowArtifactSessionOptions, TileflowArtifactSessionState, TileflowBuildArtifacts, TileflowBuildArtifactsOptions, TileflowBuildStyleInspections, TileflowHostedManifestOverwriteError, TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, TileflowManifestOptions, WriteTileflowArtifactPlanOptions, WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, writeTileflowArtifactPlan, writeTileflowBuildArtifacts } from './artifacts.js';
+export { LoadTileflowConfigOptions, LoadedTileflowConfig, TileflowValidationError, assertValidTileflowConfig, defaultTileflowApiUrl, defaultTileflowConfigPath, defaultTileflowManifestPath, getFirstTileflowMapName, getTileflowMapNames, loadTileflowConfig, loadTileflowConfigWithInputs, loadValidTileflowConfig, loadValidTileflowConfigWithInputs } from './config.js';
+export { CompiledTileflowFontBundle, PrepareTileflowStyleFontsOptions, PreparedTileflowStyleFonts, TileflowFontCompilationError, TileflowFontCompilationIssue, TileflowFontCompilationTarget, bindTileflowStyleFontBundle, getTileflowFontWatchPaths, prepareTileflowStyleFonts, replaceTileflowStyleFontSources } from './fonts.js';
+export { CompileTileflowIconPackagesResult, CompiledTileflowIconPackage, CompiledTileflowIconPackageFile, InspectTileflowIconCatalogsOptions, PreparedTileflowBuildCatalog, PreparedTileflowCatalog, TileflowBuildAsset, TileflowIconCatalog, TileflowIconCatalogAtlasRectangle, TileflowIconCatalogIcon, TileflowIconCatalogInspection, TileflowIconCatalogMap, TileflowIconCatalogRenderedDensity, TileflowIconCatalogSourceFormat, TileflowIconCompilationError, TileflowIconCompilationIssue, TileflowIconCompilationTarget, TileflowIconReplacement, TileflowMapIconPackageBinding, TileflowSourceCatalog, compileTileflowIconPackages, getTileflowIconWatchPaths, iconFileExtensions, inspectTileflowIconCatalogs, prepareTileflowCatalogIcons } from './icons.js';
+export { TileflowConfigInspection, TileflowConfigInspectionError, TileflowConfigInspectionOptions, TileflowFeatureInspection, TileflowFeatureInspectionOptions, TileflowInspectedFeature, TileflowInspectedProperty, TileflowMapLineageInspection, TileflowMapMergeProvenance, TileflowResolvedMapInspection, TileflowThemeContractInspection, TileflowThemeDifferenceInspection, TileflowThemeInspection, inspectLoadedTileflowConfig, inspectTileflowConfig, inspectTileflowFeatures, sanitizeTileflowInspectableValue } from './inspect.js';
+export { ResolvedTileflowPreview, TileflowLandmark, TileflowLandmarkArchive, TileflowLandmarkAxisConvention, TileflowLandmarkManifestV2, TileflowLandmarkModel, TileflowPreviewSelection, TileflowPreviewSelectionError, normalizeTileflowLandmarkManifest, readBoundedTileflowJsonResponse, readBoundedTileflowResponse, renderTileflowPreviewHtml, resolveTileflowPreview } from './preview.js';
+export { TileflowComparisonMode, TileflowComparisonOptions, TileflowComparisonRequestHandler, TileflowComparisonSide, TileflowDevRequestHandler, TileflowDevRequestHandlerOptions, createTileflowArtifactStatus, createTileflowComparisonRequestHandler, createTileflowDevRequestHandler, createTileflowNodeRequest, getTileflowRequestPath, getTileflowStyleInspectionSelection, getTileflowStyleSelection, isTileflowRequestUrl, tileflowComparisonSchemaVersion, writeTileflowNodeResponse } from './server.js';
+export { T as TileflowLocalTilesetInspection, a as TileflowTilesetInspectionV1, b as TileflowTilesetInspectionWarning, i as inspectTileflowPmtiles, c as inspectTileflowPmtilesForLocalUse } from './tilesets-C0tGeenP.js';
+export { TileflowCommandFailureDocument, TileflowCommandSummary, TileflowDiagnosticSeverity, TileflowStructuredDiagnostic, TileflowStyleValidationError, TileflowStyleValidationIssue, assertValidTileflowStyle, createTileflowCommandFailureDocument, createTileflowCommandSummary, createTileflowStructuredDiagnostics, sanitizeDiagnosticSecrets, serializeTileflowCommandDocument, tileflowCommandDocumentSchemaVersion, validateTileflowStyle } from './validation.js';
+import '@tileflow/core';
+import '@tileflow/core/build';
+import '@tileflow/core/manifest';
+import 'node:http';