@tangram.gl/tangram-layers 0.0.0-stage → 0.0.1

package/dist/types/index.d.ts

@@ -0,0 +1,84 @@
+import { Layer } from '@deck.gl/core';
+import createTangramLayerClass, { getExternalCameraFrame, getFirstPersonViewFrame, getGlobeViewFrame, injectNextzenApiKey } from './tangram-layer.js';
+import type { TangramLayerProps } from './tangram-layer.js';
+declare const BaseTangramLayer: {
+    new (...properties: Partial<TangramLayerProps>[]): {
+        props: Partial<TangramLayerProps>;
+        context: import("./tangram-layer-lifecycle.js").TangramLayerContext;
+        state: {
+            tangramRecord?: import("./tangram-layer-lifecycle.js").TangramRecord | null;
+        };
+        setState: (state: Record<string, unknown>) => void;
+        setNeedsRedraw: () => void;
+        raiseError: (error: Error, message: string) => void;
+        initializeState(_context?: import("@deck.gl/core").LayerContext): void;
+        updateState({ props }: {
+            props: Partial<TangramLayerProps>;
+        }): void;
+        draw({ renderPass }?: {
+            renderPass?: import("@luma.gl/core").RenderPass;
+        }): void;
+        finalizeState(_context?: import("@deck.gl/core").LayerContext): void;
+        getFeatureAt(pixel: {
+            x: number;
+            y: number;
+        }, options?: import("@tangram.gl/tangram-renderer").FeatureSelectionOptions): Promise<import("@tangram.gl/tangram-renderer").FeatureSelectionResult | undefined>;
+        getTerrainAt(pixel: {
+            x: number;
+            y: number;
+        }, surface?: import("@tangram.gl/tangram-renderer").TerrainSurface, options?: import("@tangram.gl/tangram-renderer").FeatureSelectionOptions): import("@tangram.gl/tangram-renderer").TerrainSurfaceHit | null;
+        getDrapedTerrainSurface(): import("@tangram.gl/tangram-renderer").DrapedTerrainSurfaceSnapshot | null;
+        getTerrainDrapingStatistics(): import("@tangram.gl/tangram-renderer").TerrainDrapingStatistics | undefined;
+        get isLoaded(): boolean;
+        _createTangramRecord(props: Partial<TangramLayerProps>): import("./tangram-layer-lifecycle.js").TangramRecord | null;
+        _updateAttributions(record: import("./tangram-layer-lifecycle.js").TangramRecord): void;
+        _synchronizeTangramScene(record: import("./tangram-layer-lifecycle.js").TangramRecord): void;
+        _canRender(record: import("./tangram-layer-lifecycle.js").TangramRecord, props: Partial<TangramLayerProps>): boolean;
+        _raiseViewportError(record: import("./tangram-layer-lifecycle.js").TangramRecord, error: Error): void;
+        _reportSceneError(record: import("./tangram-layer-lifecycle.js").TangramRecord, error: Error, isFatal?: boolean): void;
+        _raiseBridgeError(error: Error): void;
+        _disposeTangramRecord(record: import("./tangram-layer-lifecycle.js").TangramRecord | null | undefined): void;
+        _destroyTangramRecord(record: import("./tangram-layer-lifecycle.js").TangramRecord): void;
+        _withDeviceState<Value>(record: import("./tangram-layer-lifecycle.js").PendingTangramRecord, callback: () => Value): Value;
+    };
+    layerName: string;
+    defaultProps: Record<string, unknown>;
+};
+/**
+ * A deck.gl basemap layer that renders a Tangram scene into deck's active
+ * luma.gl device and render pass.
+ */
+declare class TangramLayer extends BaseTangramLayer {
+    /** Preserve deck.gl's complete public context rather than only the bridge capabilities. */
+    context: Layer<TangramLayerProps>['context'];
+    /** Public layer properties retain deck's resolved defaults. */
+    props: Layer<TangramLayerProps>['props'];
+    /** Preserve deck's state update signature through the injected base class. */
+    setState: Layer<TangramLayerProps>['setState'];
+    /** Keep deck's public state surface while the internal adapter checks its own record. */
+    state: Layer<TangramLayerProps>['state'];
+    /** Stable deck.gl metadata for the typed public subclass. */
+    static componentName: string;
+    /** Compatibility name for integrations using deck.gl's historical metadata. */
+    static layerName: string;
+    /** Preserve deck.gl's public initialization signature through the injected superclass. */
+    initializeState(_context: Layer<TangramLayerProps>['context']): void;
+    /** Forward the standard deck.gl property/state change contract. */
+    updateState(parameters: Parameters<Layer<TangramLayerProps>['updateState']>[0]): void;
+    /** Release the scene using the standard deck.gl finalization signature. */
+    finalizeState(_context: Layer<TangramLayerProps>['context']): void;
+    /** Forward deck's complete draw options to the existing render-pass bridge. */
+    draw(options: Parameters<Layer<TangramLayerProps>['draw']>[0]): void;
+}
+/** deck.gl fields inherited through the dependency-injected runtime superclass. */
+interface TangramLayer extends Layer<TangramLayerProps> {
+}
+export { TangramLayer, createTangramLayerClass, getExternalCameraFrame, getFirstPersonViewFrame, getGlobeViewFrame, injectNextzenApiKey };
+export default TangramLayer;
+export type { TangramLayerProps } from './tangram-layer.js';
+export { default as WebMercatorViewAdapter } from './web_mercator_view_adapter.js';
+export { default as FirstPersonViewAdapter } from './first_person_view_adapter.js';
+export type { FirstPersonViewAdapterOptions } from './first_person_view_adapter.js';
+export { default as GlobeViewAdapter } from './globe_view_adapter.js';
+export type { GlobeViewAdapterOptions } from './globe_view_adapter.js';
+export type { FirstPersonViewport, GlobeViewport, PlanarCameraViewport } from './view_adapter_types.js';

package/dist/types/tangram-layer-lifecycle.d.ts

@@ -0,0 +1,132 @@
+import type { Device, RenderPass } from '@luma.gl/core';
+import type { Scene } from '@tangram.gl/tangram-renderer';
+import type { Renderer, RendererOptions, SceneDefinition, SceneListeners, SceneLoadOptions, RenderOptions } from '@tangram.gl/tangram-renderer/core';
+import type { TangramLayerProps } from "./tangram-layer.js";
+import type { FirstPersonViewport } from "./view_adapter_types.js";
+/** Geographic viewport capabilities read by the existing view dispatch. */
+export interface TangramLayerViewport extends FirstPersonViewport {
+    /** Camera bearing in degrees. */
+    bearing?: number;
+    /** Class metadata used by deck.gl's existing experimental globe/first-person adapters. */
+    constructor: Function & {
+        displayName?: string;
+    };
+    /** Optional globe eye and visible-boundary capabilities. */
+    cameraPosition?: ArrayLike<number>;
+    getBounds?: (options: {
+        z: number;
+    }) => unknown;
+}
+/** Device state tracked only on the WebGL branch of the bridge. */
+export interface TangramBridgeDevice extends Device {
+    /** Optional WebGL state stack, validated before constructing a WebGL record. */
+    pushState?: () => void;
+    popState?: () => void;
+}
+/** Renderer scene capabilities needed by the bridge, without exposing scene implementation state. */
+export interface TangramBridgeScene {
+    /** Normalized animation policy, absent before loading. */
+    config?: {
+        scene?: {
+            animated?: boolean;
+        };
+    } | null;
+    /** Main-thread context ownership used only for WebGL submission. */
+    withWebGLContext?<Value>(operation: () => Value): Value;
+}
+/** Narrow injected renderer API; GPU resources and workers remain renderer-owned. */
+export interface TangramBridgeRenderer extends Pick<Renderer, 'setFrame' | 'setTerrain' | 'setTerrainExaggeration' | 'getFeatureAt' | 'getTerrainAt' | 'getDrapedTerrainSurface' | 'getTerrainDrapingStatistics' | 'getAttributions' | 'destroy' | 'setProjectedBasemapProjection'> {
+    /** Scene owned by this renderer instance. */
+    scene: Scene;
+    /** Scene event registration. */
+    subscribe(listeners: SceneListeners): unknown;
+    /** Asynchronous scene load; synchronous legacy returns remain supported. */
+    load(scene: SceneDefinition, options: SceneLoadOptions): unknown;
+    /** Submit one host frame through the caller's active render pass. */
+    render(options: RenderOptions): boolean;
+}
+/** Factory injection preserves both the current and legacy renderer argument names. */
+export interface TangramRendererFactory {
+    /** Construct one independently owned renderer; missing factories still fail through the existing catch path. */
+    create?: (scene: SceneDefinition, options: RendererOptions & {
+        requestRedraw: () => void;
+    }) => TangramBridgeRenderer;
+}
+/** deck lifecycle capabilities inherited from the injected superclass. */
+export interface TangramLayerOwner {
+    /** Resolved deck properties, including callback defaults. */
+    props: Partial<TangramLayerProps>;
+    /** Notify deck that asynchronous scene work needs another frame. */
+    setNeedsRedraw(): void;
+    /** Forward existing error reporting to deck. */
+    raiseError(error: Error, message: string): void;
+    /** Existing error callback used by the opt-in projected subclass. */
+    _reportSceneError(record: TangramRecord, error: Error, isFatal?: boolean): void;
+}
+/** Scene ownership shared by callbacks when deck replaces its layer instance. */
+export interface TangramRecord {
+    /** Latest layer instance holding the logical scene. */
+    owner: TangramLayerOwner;
+    /** Assigned renderer and scene, after successful factory construction. */
+    renderer: TangramBridgeRenderer;
+    scene: Scene;
+    /** Device and optional native WebGL context. */
+    device: TangramBridgeDevice;
+    gl: (WebGLRenderingContext & {
+        lumaState?: {
+            program?: WebGLProgram | null;
+        };
+    }) | null;
+    /** Host canvas never replaced by Tangram. */
+    deckCanvas: HTMLCanvasElement;
+    /** Immutable constructor input identities. */
+    sceneSource: SceneDefinition;
+    sceneBasePath?: string | null;
+    apiKey?: string | null;
+    projectionEngine?: TangramLayerProps['projectionEngine'];
+    projectionEngineExecution?: TangramLayerProps['projectionEngineExecution'];
+    maxConcurrentTileLoadsPerWorker?: number;
+    /** Current asynchronous terrain request and latest relief policy. */
+    terrain?: TangramLayerProps['terrain'];
+    /** Immutable borrowed admission-pool identity. */
+    terrainResourceBudget?: TangramLayerProps['terrainResourceBudget'];
+    terrainRevision?: number;
+    terrainPendingRevision: number;
+    /** Current canvas CSS size, assigned during view synchronization. */
+    canvasWidth: number | null;
+    canvasHeight: number | null;
+    /** Disposal waits for an in-flight load, and releases the renderer once. */
+    disposed: boolean;
+    destroyed: boolean;
+    loadSettled: boolean;
+    loadFailed: boolean;
+    loaded: boolean;
+    loadPromise: Promise<unknown> | null;
+    /** Deduplicated scene/viewport errors and attribution request generation. */
+    lastSceneError: string | null;
+    lastViewportError: string | null;
+    reportedViewportError: string | null;
+    attributionGeneration?: number;
+    /** Latest opt-in projected mesh generation requested by the projected subclass. */
+    projectedProjectionKey?: string | null;
+    /** Reentrant WebGL state-scope depth. */
+    webglScopeDepth: number;
+}
+/** Record initialization happens before the factory is called so redraw callbacks can close over it. */
+export type PendingTangramRecord = Omit<TangramRecord, 'renderer' | 'scene'> & {
+    renderer: TangramBridgeRenderer | null;
+    scene: TangramBridgeScene | null;
+};
+/** Required host context capabilities, with no dependency on a concrete deck.gl subclass. */
+export interface TangramLayerContext {
+    /** Host device validated by the existing creation path. */
+    device: TangramBridgeDevice;
+    /** Current viewport plus the complete view inventory. */
+    viewport: TangramLayerViewport;
+    deck?: {
+        getCanvas(): HTMLCanvasElement | null;
+        getViewports?(): readonly TangramLayerViewport[];
+    };
+    /** Caller-owned pass; undefined keeps the existing renderer fallback. */
+    renderPass?: RenderPass;
+}

package/dist/types/tangram-layer.d.ts

@@ -0,0 +1,157 @@
+import WebMercatorViewAdapter from './web_mercator_view_adapter.js';
+import type { GlobeViewAdapterOptions } from './globe_view_adapter.js';
+import type { FirstPersonViewAdapterOptions } from './first_person_view_adapter.js';
+import type { FirstPersonViewport, GlobeViewport } from './view_adapter_types.js';
+import type { HostFrameOptions } from '@tangram.gl/tangram-renderer/core';
+import type { ProjectionEngine, ProjectionExecutionOptions } from '@tangram.gl/tangram-renderer/core';
+import type { LayerProps } from '@deck.gl/core';
+import type { Scene } from '@tangram.gl/tangram-renderer';
+import type { SceneDefinition, FeatureSelectionOptions, FeatureSelectionResult } from '@tangram.gl/tangram-renderer/core';
+import type { TerrainSurface, TerrainSurfaceHit } from '@tangram.gl/tangram-renderer/core';
+import type { HostTileResourceOptions } from '@tangram.gl/tangram-renderer/core';
+import type { TangramRecord, PendingTangramRecord, TangramRendererFactory, TangramLayerContext } from "./tangram-layer-lifecycle.js";
+/** Tangram-specific properties in addition to ordinary deck.gl layer properties. */
+export type TangramLayerProps = LayerProps & {
+    /** Inline scene or URL loaded by the renderer. */
+    scene: SceneDefinition;
+    /** Opt-in physical-height draping; host owns DEM acquisition and supplies immutable grids. */
+    terrain?: import('@tangram.gl/tangram-renderer/core').RendererOptions['terrain'];
+    /** Borrowed application admission pool, shared with terrain acquisition; changing it recreates the renderer. */
+    terrainResourceBudget?: import('@tangram.gl/tangram-renderer/core').RendererOptions['terrainResourceBudget'];
+    /** Visual terrain relief multiplier; changing it does not refetch or rebuild meshes. */
+    terrainExaggeration?: number;
+    /** Caller-owned CRS factory for CPU-projected basemaps; omitted keeps worker-local math.gl transforms. */
+    projectionEngine?: ProjectionEngine;
+    /** Immutable host kernel chunking policy; changing it recreates the scene, like changing the engine. */
+    projectionEngineExecution?: ProjectionExecutionOptions;
+    /** Base URL used by imported scenes and assets. */
+    sceneBasePath?: string | null;
+    /** Optional Nextzen source key injected on load. */
+    apiKey?: string | null;
+    /** Conservative globe visibility settings. */
+    globeMaxElevation?: number;
+    globeVisibleBounds?: readonly [number, number, number, number];
+    globePreloadZoom?: number;
+    /** Shared styled mesh-resource and decoded-acquisition limits. */
+    tileResources?: HostTileResourceOptions;
+    maxConcurrentTileLoadsPerWorker?: number | null;
+    /** Bounded first-person ground/slab footprint. */
+    firstPersonMaxGroundExtent?: number;
+    firstPersonElevationRange?: readonly [number, number];
+    /** Scene and attribution lifecycle callbacks, resolved by deck defaults. */
+    onSceneLoad?: (scene: Scene) => void;
+    onSceneError?: (error: Error, scene: Scene) => void;
+    onAttributionChange?: (credits: string[], scene: Scene) => void;
+    /** Optional CPU-projected subclass's existing callback and projection policy. */
+    projectedProjection?: import('@tangram.gl/tangram-renderer/core').ProjectedBasemapOptions;
+    onProjectionChange?: (projection: import('@tangram.gl/tangram-renderer/core').ProjectedBasemapOptions) => void;
+    /** Remaining existing Tangram bridge properties. */
+    [property: string]: unknown;
+};
+/** Opt-in host adapter, kept independent of the ordinary geographic view dispatch. */
+export interface TangramHostViewAdapter {
+    /** Validate and adapt a host viewport before modifying renderer state. */
+    getFrame(viewport: unknown, properties: unknown, dimensions: {
+        width: number;
+        height: number;
+    }): HostFrameOptions;
+}
+/**
+ * Injects an API key into every Nextzen source in a Tangram scene.
+ *
+ * @param {object} config Tangram scene configuration.
+ * @param {string|null|undefined} apiKey Nextzen API key.
+ * @returns {boolean} `true` when at least one source was updated.
+ */
+export declare function injectNextzenApiKey(config: {
+    sources?: Record<string, {
+        url?: unknown;
+        url_params?: Record<string, unknown>;
+    } | null>;
+} | null | undefined, apiKey?: string | null): boolean;
+/**
+ * Converts a deck.gl Web Mercator viewport into Tangram camera matrices.
+ *
+ * Tangram tile models use absolute EPSG:3857 meters while deck matrices consume
+ * zoom-zero common coordinates. Altitude remains in physical meters and uses
+ * deck's latitude-dependent distance scale.
+ *
+ * @param {object} viewport deck.gl WebMercatorViewport.
+ * @returns {{view: Float64Array, projection: Float32Array, position: number[]}}
+ */
+export declare function getExternalCameraFrame(viewport: Parameters<typeof WebMercatorViewAdapter.getCameraFrame>[0]): {
+    view: Float64Array;
+    projection: Float32Array;
+    position: [number, number, number];
+};
+/** Converts a finite first-person camera into a bounded flat-ground host frame. */
+export declare function getFirstPersonViewFrame(viewport: FirstPersonViewport, options?: FirstPersonViewAdapterOptions): import("@tangram.gl/tangram-renderer").LegacyHostFrame;
+export declare function getGlobeViewFrame(viewport: GlobeViewport, options?: GlobeViewAdapterOptions): import("@tangram.gl/tangram-renderer").LegacyHostFrame;
+/**
+ * Creates an experimental deck.gl layer class that renders Tangram through
+ * Tangram's luma.gl device renderer.
+ *
+ * The class is dependency-injected so this demo does not add deck.gl as a Tangram
+ * package dependency.
+ *
+ * @param {object} dependencies Bridge dependencies.
+ * @param {typeof import('@deck.gl/core').Layer} dependencies.Layer deck.gl Layer class.
+ * @param {object} dependencies.ClassicWebGLRenderer Embeddable Tangram renderer class.
+ * @param {object} dependencies.Renderer Legacy alias for ClassicWebGLRenderer.
+ * @returns {typeof import('@deck.gl/core').Layer} TangramLayer class.
+ */
+export declare function createTangramLayerClass({ Layer, ClassicWebGLRenderer, Renderer }: {
+    Layer: abstract new (...properties: Partial<TangramLayerProps>[]) => object;
+    ClassicWebGLRenderer?: TangramRendererFactory;
+    Renderer?: TangramRendererFactory;
+}, viewAdapter?: TangramHostViewAdapter): {
+    new (...properties: Partial<TangramLayerProps>[]): {
+        /** Inherited host capabilities are supplied by the injected deck superclass. */
+        props: Partial<TangramLayerProps>;
+        context: TangramLayerContext;
+        state: {
+            tangramRecord?: TangramRecord | null;
+        };
+        setState: (state: Record<string, unknown>) => void;
+        setNeedsRedraw: () => void;
+        raiseError: (error: Error, message: string) => void;
+        initializeState(_context?: import("@deck.gl/core").LayerContext): void;
+        updateState({ props }: {
+            props: Partial<TangramLayerProps>;
+        }): void;
+        draw({ renderPass }?: {
+            renderPass?: import("@luma.gl/core").RenderPass;
+        }): void;
+        finalizeState(_context?: import("@deck.gl/core").LayerContext): void;
+        /** Asynchronously query a view-local or canvas CSS pixel; the host must keep drawing. */
+        getFeatureAt(pixel: {
+            x: number;
+            y: number;
+        }, options?: FeatureSelectionOptions): Promise<FeatureSelectionResult | undefined>;
+        /** Intersect the actual rendered eye with a host-owned terrain mesh in content coordinates. */
+        getTerrainAt(pixel: {
+            x: number;
+            y: number;
+        }, surface?: TerrainSurface, options?: FeatureSelectionOptions): TerrainSurfaceHit | null;
+        /** Exact admitted ground triangles at the last frame, including temporal relief and globe projection. */
+        getDrapedTerrainSurface(): import("@tangram.gl/tangram-renderer/core").DrapedTerrainSurfaceSnapshot | null;
+        /** Resident worker preparation costs; GPU, source and scratch allocations are separate. */
+        getTerrainDrapingStatistics(): import("@tangram.gl/tangram-renderer/core").TerrainDrapingStatistics | undefined;
+        get isLoaded(): boolean;
+        _createTangramRecord(props: Partial<TangramLayerProps>): TangramRecord | null;
+        /** Refresh credits after source recreation; ignore stale metadata and disposed layers. */
+        _updateAttributions(record: TangramRecord): void;
+        _synchronizeTangramScene(record: TangramRecord): void;
+        _canRender(record: TangramRecord, props: Partial<TangramLayerProps>): boolean;
+        _raiseViewportError(record: TangramRecord, error: Error): void;
+        _reportSceneError(record: TangramRecord, error: Error, isFatal?: boolean): void;
+        _raiseBridgeError(error: Error): void;
+        _disposeTangramRecord(record: TangramRecord | null | undefined): void;
+        _destroyTangramRecord(record: TangramRecord): void;
+        _withDeviceState<Value>(record: PendingTangramRecord, callback: () => Value): Value;
+    };
+    /** Existing deck metadata assigned below without changing constructor output. */
+    layerName: string;
+    defaultProps: Record<string, unknown>;
+};
+export default createTangramLayerClass;

package/dist/types/view_adapter_types.d.ts

@@ -0,0 +1,42 @@
+/** deck.gl's planar camera surface, independent of concrete viewport subclasses. */
+export interface PlanarCameraViewport {
+    longitude?: number;
+    latitude?: number;
+    zoom?: number;
+    pitch?: number;
+    height?: number;
+    isGeospatial?: boolean;
+    viewMatrix?: ArrayLike<number> | null;
+    projectionMatrix?: ArrayLike<number> | null;
+    distanceScales?: {
+        unitsPerMeter?: ArrayLike<number>;
+    };
+    getDistanceScales?: () => {
+        unitsPerMeter?: ArrayLike<number>;
+    };
+}
+/** Public methods required to derive a FirstPersonView ground footprint. */
+export interface FirstPersonViewport extends PlanarCameraViewport {
+    width: number;
+    height: number;
+    position?: ArrayLike<number>;
+    unproject?: (pixel: number[], options?: {
+        targetZ: number;
+    }) => number[];
+    projectFlat?: (coordinate: number[]) => number[];
+    unprojectFlat?: (coordinate: number[]) => number[];
+}
+/** Public GlobeView matrix and geographic-bounds contract. */
+export interface GlobeViewport {
+    width: number;
+    height: number;
+    longitude: number;
+    latitude: number;
+    zoom: number;
+    viewMatrix?: ArrayLike<number>;
+    projectionMatrix?: ArrayLike<number>;
+    cameraPosition?: ArrayLike<number>;
+    getBounds?: (options: {
+        z: number;
+    }) => unknown;
+}

package/dist/types/web_mercator_view_adapter.d.ts

@@ -0,0 +1,77 @@
+type Matrix = ArrayLike<number>;
+interface DistanceScales {
+    unitsPerMeter?: ArrayLike<number>;
+}
+interface WebMercatorViewport {
+    longitude?: number;
+    latitude?: number;
+    zoom?: number;
+    pitch?: number;
+    height?: number;
+    isGeospatial?: boolean;
+    viewMatrix?: Matrix | null;
+    projectionMatrix?: Matrix | null;
+    distanceScales?: DistanceScales;
+    getDistanceScales?: () => DistanceScales;
+}
+interface RenderDimensions {
+    width: number;
+    height: number;
+}
+interface TangramCameraFrame {
+    view: Float64Array;
+    projection: Float32Array;
+    position: [number, number, number];
+}
+/**
+ * Adapts deck.gl Web Mercator viewports to Tangram's host-frame contract.
+ *
+ * The adapter keeps deck-specific viewport validation and matrix conversion
+ * out of the layer lifecycle while preserving Tangram's EPSG:3857 meter frame.
+ */
+export default class WebMercatorViewAdapter {
+    /**
+     * Checks that a deck viewport provides the public Web Mercator contract used
+     * by TangramLayer.
+     * @param viewport deck.gl viewport.
+     * @returns Validation error, or null when supported.
+     */
+    static validateViewport(viewport: WebMercatorViewport): Error | null;
+    /**
+     * Validates the geographic anchor shared by all deck.gl view adapters.
+     * @param viewport deck.gl viewport.
+     * @param viewportName View name used in the error message.
+     * @returns Validation error, or null when the anchor is finite.
+     */
+    static validateGeographicAnchor(viewport: WebMercatorViewport, viewportName?: string): Error | null;
+    /**
+     * Converts deck.gl camera matrices to Tangram camera matrices.
+     *
+     * Tangram tile models use absolute EPSG:3857 meters while deck matrices
+     * consume zoom-zero common coordinates. Altitude uses deck's
+     * latitude-dependent distance scale.
+     * @param viewport deck.gl WebMercatorViewport.
+     * @returns Tangram camera matrices and eye position.
+     */
+    static getCameraFrame(viewport: WebMercatorViewport): TangramCameraFrame;
+    /**
+     * Builds Tangram's external-camera frame for a deck.gl MapView.
+     * @param viewport deck.gl WebMercatorViewport.
+     * @param dimensions Render-target size.
+     * @returns Tangram HostFrame legacy shape.
+     */
+    static getFrame(viewport: WebMercatorViewport, { width, height }: RenderDimensions): {
+        viewport: RenderDimensions;
+        view: {
+            longitude: number;
+            latitude: number;
+            zoom: number;
+        };
+        projection: {
+            type: 'web-mercator';
+        };
+        camera: TangramCameraFrame;
+        tileBuffer: number;
+    };
+}
+export {};

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@tangram.gl/tangram-layers",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "homepage": "https://vis.gl/tangram.gl/",
+  "version": "0.0.1",
+  "description": "deck.gl layers for Tangram basemaps",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./experimental/webxr": {
+      "types": "./src/experimental/webxr/index.d.ts",
+      "import": "./dist/experimental/webxr.js",
+      "default": "./dist/experimental/webxr.js"
+    },
+    "./experimental/projected-basemaps": {
+      "types": "./dist/types/experimental/projected-basemaps.d.ts",
+      "import": "./dist/experimental/projected-basemaps.js",
+      "default": "./dist/experimental/projected-basemaps.js"
+    },
+    "./experimental/terrain": {
+      "types": "./dist/types/experimental/terrain.d.ts",
+      "import": "./dist/experimental/terrain.js",
+      "default": "./dist/experimental/terrain.js"
+    },
+    "./dist/*": "./dist/*"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visgl/tangram.gl.git",
+    "directory": "modules/tangram-layers"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "yarn build:types && yarn build:bundle",
+    "build:types": "node ../../scripts/build-package-types.mjs modules/tangram-layers index.ts experimental/projected-basemaps.ts experimental/terrain.ts",
+    "build:bundle": "yarn build:bundle:main && yarn build:bundle:webxr && yarn build:bundle:projected && yarn build:bundle:terrain",
+    "build:bundle:terrain": "ocular-bundle ./experimental-terrain.js --env=dev --output=dist/experimental/terrain.js --externals=@tangram.gl/tangram-renderer --sourcemap=true --sourcesContent=false",
+    "build:bundle:projected": "ocular-bundle ./experimental-projected-basemaps.js --env=dev --output=dist/experimental/projected-basemaps.js --externals=@tangram.gl/tangram-renderer --sourcemap=true --sourcesContent=false",
+    "build:bundle:main": "ocular-bundle ./bundle.js --env=dev --output=dist/index.js --externals=@tangram.gl/tangram-renderer --sourcemap=true --sourcesContent=false",
+    "build:bundle:webxr": "ocular-bundle ./experimental-webxr.js --env=dev --output=dist/experimental/webxr.js --externals=@tangram.gl/tangram-renderer --sourcemap=true --sourcesContent=false",
+    "prepack": "yarn build"
+  },
+  "devDependencies": {
+    "@vis.gl/dev-tools": "2.0.0-alpha.8",
+    "playwright": "^1.58.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@math.gl/culling": "5.0.0-alpha.18",
+    "@tangram.gl/tangram-renderer": "^0.0.1"
+  },
+  "peerDependencies": {
+    "@deck.gl/core": "^9.4.0",
+    "@deck.gl/mesh-layers": "^9.4.0",
+    "@luma.gl/core": "^9.4.2",
+    "@luma.gl/experimental": "^9.4.2",
+    "@math.gl/core": "5.0.0-alpha.18",
+    "@math.gl/projection": "5.0.0-alpha.18",
+    "mjolnir.js": "^3.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@deck.gl/mesh-layers": {
+      "optional": true
+    },
+    "@math.gl/projection": {
+      "optional": true
+    }
+  }
 }