@baidumap/mapv-three 1.0.0

package/dist/types/threemap/mapView/mapbox/expression/definitions/length.d.ts

@@ -0,0 +1,13 @@
+export default Length;
+declare class Length {
+    static parse(args: any, context: any): any;
+    constructor(input: any);
+    type: {
+        kind: string;
+    };
+    input: any;
+    evaluate(ctx: any): number;
+    eachChild(fn: any): void;
+    outputDefined(): boolean;
+    serialize(): string[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/let.d.ts

@@ -0,0 +1,12 @@
+export default Let;
+declare class Let {
+    static parse(args: any, context: any): any;
+    constructor(bindings: any, result: any);
+    type: any;
+    bindings: never[];
+    result: any;
+    evaluate(ctx: any): any;
+    eachChild(fn: any): void;
+    outputDefined(): any;
+    serialize(): string[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/literal.d.ts

@@ -0,0 +1,11 @@
+export default Literal;
+declare class Literal {
+    static parse(args: any, context: any): any;
+    constructor(type: any, value: any);
+    type: any;
+    value: any;
+    evaluate(): any;
+    eachChild(): void;
+    outputDefined(): boolean;
+    serialize(): any;
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/match.d.ts

@@ -0,0 +1,15 @@
+export default Match;
+declare class Match {
+    static parse(args: any, context: any): any;
+    constructor(inputType: any, outputType: any, input: any, cases: any, outputs: any, otherwise: any);
+    type: any;
+    inputType: any;
+    input: any;
+    cases: any;
+    outputs: any;
+    otherwise: any;
+    evaluate(ctx: any): any;
+    eachChild(fn: any): void;
+    outputDefined(): any;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/number_format.d.ts

@@ -0,0 +1,17 @@
+export default class NumberFormat {
+    static parse(args: any, context: any): any;
+    constructor(number: any, locale: any, currency: any, unit: any, minFractionDigits: any, maxFractionDigits: any);
+    type: {
+        kind: string;
+    };
+    number: any;
+    locale: any;
+    currency: any;
+    unit: any;
+    minFractionDigits: any;
+    maxFractionDigits: any;
+    evaluate(ctx: any): string;
+    eachChild(fn: any): void;
+    outputDefined(): boolean;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/slice.d.ts

@@ -0,0 +1,13 @@
+export default Slice;
+declare class Slice {
+    static parse(args: any, context: any): any;
+    constructor(type: any, input: any, beginIndex: any, endIndex: any);
+    type: any;
+    input: any;
+    beginIndex: any;
+    endIndex: any;
+    evaluate(ctx: any): any;
+    eachChild(fn: any): void;
+    outputDefined(): boolean;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/step.d.ts

@@ -0,0 +1,13 @@
+export default Step;
+declare class Step {
+    static parse(args: any, context: any): any;
+    constructor(type: any, input: any, stops: any);
+    type: any;
+    input: any;
+    labels: any[];
+    outputs: any[];
+    evaluate(ctx: any): any;
+    eachChild(fn: any): void;
+    outputDefined(): boolean;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/var.d.ts

@@ -0,0 +1,12 @@
+export default Var;
+declare class Var {
+    static parse(args: any, context: any): any;
+    constructor(name: any, boundExpression: any);
+    type: any;
+    name: any;
+    boundExpression: any;
+    evaluate(ctx: any): any;
+    eachChild(): void;
+    outputDefined(): boolean;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/definitions/within.d.ts

@@ -0,0 +1,14 @@
+export default Within;
+declare class Within {
+    static parse(args: any, context: any): any;
+    constructor(geojson: any, geometries: any);
+    type: {
+        kind: string;
+    };
+    geojson: any;
+    geometries: any;
+    evaluate(ctx: any): boolean;
+    eachChild(): void;
+    outputDefined(): boolean;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/evaluation_context.d.ts

@@ -0,0 +1,20 @@
+export default EvaluationContext;
+declare class EvaluationContext {
+    globals: any;
+    feature: any;
+    featureState: any;
+    formattedSection: any;
+    availableImages: any;
+    canonical: any;
+    featureTileCoord: any;
+    featureDistanceData: any;
+    /** @private */
+    private _parseColorCache;
+    id(): any;
+    geometryType(): any;
+    geometry(): any;
+    canonicalID(): any;
+    properties(): any;
+    distanceFromCenter(): number;
+    parseColor(input: any): any;
+}

package/dist/types/threemap/mapView/mapbox/expression/expression.d.ts

@@ -0,0 +1,11 @@
+export default class Expression {
+    type: any;
+    evaluate(ctx: any): void;
+    eachChild(fn: any): void;
+    /**
+     * Statically analyze the expression, attempting to enumerate possible outputs. Returns
+     * false if the complete set of outputs is statically undecidable, otherwise true.
+     */
+    outputDefined(): void;
+    serialize(): void;
+}

package/dist/types/threemap/mapView/mapbox/expression/index.d.ts

@@ -0,0 +1,39 @@
+export function isExpression(expression: any): boolean;
+export function createPropertyExpression(expression: any, propertySpec: any): any;
+export function createExpression(expression: any, propertySpec: any): {
+    result: string;
+    value: any[];
+} | {
+    result: string;
+    value: StyleExpression;
+};
+export class StyleExpression {
+    constructor(expression: any, propertySpec: any);
+    expression: any;
+    _evaluator: EvaluationContext;
+    _defaultValue: any;
+    _warningHistory: {};
+    _enumValues: any;
+    evaluateWithoutErrorHandling(globals: any, feature: any, featureState: any, canonical: any, availableImages: any, formattedSection: any, featureTileCoord: any, featureDistanceData: any): any;
+    evaluate(globals: any, feature: any, featureState: any, canonical: any, availableImages: any, formattedSection: any, featureTileCoord: any, featureDistanceData: any): any;
+}
+export class ZoomConstantExpression {
+    constructor(kind: any, expression: any);
+    kind: any;
+    isStateDependent: boolean;
+    _styleExpression: any;
+    evaluateWithoutErrorHandling(globals: any, feature: any, featureState: any, canonical: any, availableImages: any, formattedSection: any): any;
+    evaluate(globals: any, feature: any, featureState: any, canonical: any, availableImages: any, formattedSection: any): any;
+}
+export class ZoomDependentExpression {
+    constructor(kind: any, expression: any, zoomStops: any, interpolationType: any);
+    kind: any;
+    zoomStops: any;
+    isStateDependent: boolean;
+    _styleExpression: any;
+    interpolationType: any;
+    evaluateWithoutErrorHandling(globals: any, feature: any, featureState: any, canonical: any, availableImages: any, formattedSection: any): any;
+    evaluate(globals: any, feature: any, featureState: any, canonical: any, availableImages: any, formattedSection: any): any;
+    interpolationFactor(input: any, lower: any, upper: any): number;
+}
+import EvaluationContext from './evaluation_context.js';

package/dist/types/threemap/mapView/mapbox/expression/is_constant.d.ts

@@ -0,0 +1,3 @@
+export function isFeatureConstant(e: any): boolean;
+export function isGlobalPropertyConstant(e: any, properties: any): boolean;
+export function isStateConstant(e: any): boolean;

package/dist/types/threemap/mapView/mapbox/expression/parsing_context.d.ts

@@ -0,0 +1,49 @@
+export default ParsingContext;
+/**
+ * State associated parsing at a given point in an expression tree.
+ * @private
+ */
+declare class ParsingContext {
+    constructor(registry: any, path: any[] | undefined, expectedType: any, scope?: Scope, errors?: any[]);
+    registry: any;
+    path: any[];
+    key: string;
+    scope: Scope;
+    errors: any[];
+    expectedType: any;
+    /**
+     * @param expr the JSON expression to parse
+     * @param index the optional argument index if this expression is an argument of
+     * a parent expression that's being parsed
+     * @param options
+     * @param options.omitTypeAnnotations set true to omit inferred type annotations.
+     * Caller beware: with this option set, the parsed expression's type
+     * will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+     * @private
+     */
+    private parse;
+    _parse(expr: any, options: any): any;
+    /**
+     * Returns a copy of this context suitable for parsing the subexpression at
+     * index `index`, optionally appending to 'let' binding map.
+     *
+     * Note that `errors` property, intended for collecting errors while
+     * parsing, is copied by reference rather than cloned.
+     * @private
+     */
+    private concat;
+    /**
+     * Push a parsing (or type checking) error into the `this.errors`
+     * @param error The message
+     * @param keys Optionally specify the source of the error at a child
+     * of the current expression at `this.key`.
+     * @private
+     */
+    private error;
+    /**
+     * Returns null if `t` is a subtype of `expected`; otherwise returns an
+     * error message and also pushes it to `this.errors`.
+     */
+    checkSubtype(expected: any, t: any): string | null;
+}
+import Scope from './scope.js';

package/dist/types/threemap/mapView/mapbox/expression/parsing_error.d.ts

@@ -0,0 +1,6 @@
+export default ParsingError;
+declare class ParsingError extends Error {
+    constructor(key: any, message: any);
+    key: any;
+    message: any;
+}

package/dist/types/threemap/mapView/mapbox/expression/scope.d.ts

@@ -0,0 +1,13 @@
+export default Scope;
+/**
+ * Tracks `let` bindings during expression parsing.
+ * @private
+ */
+declare class Scope {
+    constructor(parent: any, bindings?: any[]);
+    parent: any;
+    bindings: {};
+    concat(bindings: any): Scope;
+    get(name: any): any;
+    has(name: any): any;
+}

package/dist/types/threemap/mapView/mapbox/expression/stops.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the index of the last stop <= input, or 0 if it doesn't exist.
+ * @private
+ */
+export function findStopLessThanOrEqualTo(stops: any, input: any): number;

package/dist/types/threemap/mapView/mapbox/expression/types/collator.d.ts

@@ -0,0 +1,8 @@
+export default class Collator {
+    constructor(caseSensitive: any, diacriticSensitive: any, locale: any);
+    locale: any;
+    sensitivity: string;
+    collator: Intl.Collator;
+    compare(lhs: any, rhs: any): number;
+    resolvedLocale(): string;
+}

package/dist/types/threemap/mapView/mapbox/expression/types/formatted.d.ts

@@ -0,0 +1,17 @@
+export class FormattedSection {
+    constructor(text: any, image: any, scale: any, fontStack: any, textColor: any);
+    text: any;
+    image: any;
+    scale: any;
+    fontStack: any;
+    textColor: any;
+}
+export default class Formatted {
+    static fromString(unformatted: any): Formatted;
+    static factory(text: any): Formatted;
+    constructor(sections: any);
+    sections: any;
+    isEmpty(): boolean;
+    toString(): any;
+    serialize(): string[];
+}

package/dist/types/threemap/mapView/mapbox/expression/types/resolved_image.d.ts

@@ -0,0 +1,8 @@
+export default class ResolvedImage {
+    static fromString(name: any): ResolvedImage | null;
+    constructor(options: any);
+    name: any;
+    available: any;
+    toString(): any;
+    serialize(): any[];
+}

package/dist/types/threemap/mapView/mapbox/expression/types.d.ts

@@ -0,0 +1,57 @@
+export function array(itemType: any, N: any): {
+    kind: string;
+    itemType: any;
+    N: any;
+};
+export function toString(type: any): any;
+/**
+ * Returns null if `t` is a subtype of `expected`; otherwise returns an
+ * error message.
+ * @private
+ */
+export function checkSubtype(expected: any, t: any): string | null;
+export function isValidType(provided: any, allowedTypes: any): any;
+export function isValidNativeType(provided: any, allowedTypes: any): any;
+export namespace NullType {
+    let kind: string;
+}
+export namespace NumberType {
+    let kind_1: string;
+    export { kind_1 as kind };
+}
+export namespace StringType {
+    let kind_2: string;
+    export { kind_2 as kind };
+}
+export namespace BooleanType {
+    let kind_3: string;
+    export { kind_3 as kind };
+}
+export namespace ColorType {
+    let kind_4: string;
+    export { kind_4 as kind };
+}
+export namespace ObjectType {
+    let kind_5: string;
+    export { kind_5 as kind };
+}
+export namespace ValueType {
+    let kind_6: string;
+    export { kind_6 as kind };
+}
+export namespace ErrorType {
+    let kind_7: string;
+    export { kind_7 as kind };
+}
+export namespace CollatorType {
+    let kind_8: string;
+    export { kind_8 as kind };
+}
+export namespace FormattedType {
+    let kind_9: string;
+    export { kind_9 as kind };
+}
+export namespace ResolvedImageType {
+    let kind_10: string;
+    export { kind_10 as kind };
+}

package/dist/types/threemap/mapView/mapbox/expression/values.d.ts

@@ -0,0 +1,4 @@
+export function validateRGBA(r: any, g: any, b: any, a: any): string | null;
+export function isValue(mixed: any): boolean;
+export function typeOf(value: any): any;
+export function toString(value: any): any;

package/dist/types/threemap/mapView/mapbox/feature_filter/index.d.ts

@@ -0,0 +1,15 @@
+export default createFilter;
+/**
+ * Given a filter expressed as nested arrays, return a new function
+ * that evaluates whether a given feature (with a .properties or .tags property)
+ * passes its test.
+ *
+ * @private
+ * @param {Array} filter mapbox gl filter
+ * @param {string} layerType the type of the layer this filter will be applied to.
+ * @returns {Function} filter-evaluating function
+ */
+declare function createFilter(latest: any, filter: any[], layerType?: string): Function;
+export function isExpressionFilter(filter: any): boolean;
+export function isDynamicFilter(filter: any): boolean;
+export function extractStaticFilter(filter: any): any;

package/dist/types/threemap/mapView/mapbox/function/convert.d.ts

@@ -0,0 +1,2 @@
+export default function convertFunction(parameters: any, propertySpec: any): any[];
+export function convertTokenString(s: any): any;

package/dist/types/threemap/mapView/mapbox/function/index.d.ts

@@ -0,0 +1,13 @@
+export function isFunction(value: any): boolean;
+export function assert(expression: any): void;
+export function supportsPropertyExpression(spec: any): boolean;
+export function supportsZoomExpression(spec: any): boolean;
+export function supportsInterpolation(spec: any): any;
+export function sRGBToLinear(c: any): number;
+export function linearToSRGB(c: any): number;
+/**
+ * @param {string} text
+ * @param {Object} properties
+ * @return {string}
+ */
+export function fromTemplate(text: string, properties: Object): string;

package/dist/types/threemap/mapView/mapbox/sourceLayer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @file 存储每个瓦片的数据
+ */
+export default class SourceLayer {
+    constructor(layers: {} | undefined, indexOffset: any, tileKey: any);
+    _layers: {};
+    _fillOpaqueIndexOffset: number;
+    _fillTranslucentIndexOffset: number;
+    _fillExtrusionOpaqueIndexOffset: number;
+    _fillExtrusionTranslucentIndexOffset: number;
+    _fillPatternIndexOffset: number;
+    _lineOpaqueIndexOffset: number;
+    _lineTranslucentIndexOffset: number;
+    _lineDashedIndexOffset: number;
+    _fillWaterIndexOffset: number;
+    _fillWoodIndexOffset: number;
+    /**
+     * @private
+     * @type {number}
+     */
+    private _iconIndexOffset;
+    tileKey: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    tileSize: number;
+    setDefaultIndexOffset(indexOffset: any): void;
+    getTileLayer(name: any): any;
+    setFillOpaqueIndexOffset(num: any): void;
+    setFillTranslucentIndexOffset(num: any): void;
+    setFillExtrusionOpaqueIndexOffset(num: any): void;
+    setFillExtrusionTranslucentIndexOffset(num: any): void;
+    setFillPatternIndexOffset(num: any): void;
+    setLineOpaqueIndexOffset(num: any): void;
+    setLineTranslucentIndexOffset(num: any): void;
+    setLineDashedIndexOffset(num: any): void;
+    getFillOpaqueIndexOffset(): number;
+    getFillTranslucentIndexOffset(): number;
+    getFillExtrusionOpaqueIndexOffset(): number;
+    getFillExtrusionTranslucentIndexOffset(): number;
+    getFillPatternIndexOffset(): number;
+    getLineOpaqueIndexOffset(): number;
+    getLineTranslucentIndexOffset(): number;
+    getLineDashedIndexOffset(): number;
+    setFillWaterIndexOffset(num: any): void;
+    getFillWaterIndexOffset(): number;
+    setFillWoodIndexOffset(num: any): void;
+    getFillWoodIndexOffset(): number;
+    setIconIndexOffset(num: any): void;
+    getIconIndexOffset(): number;
+    setLayers(layers?: {}): void;
+}

package/dist/types/threemap/mapView/mapbox/sprite.d.ts

@@ -0,0 +1,91 @@
+export default class Sprite {
+    /**
+     * @param {string} spriteUrl
+     * @param {string} [accessToken]
+     */
+    constructor(spriteUrl: string, accessToken?: string);
+    /**
+     * @private
+     * @type {string}
+     */
+    private _spriteUrl;
+    /**
+     * @private
+     * @type {string}
+     */
+    private _accessToken;
+    /**
+     * @private
+     * @type {number}
+     */
+    private _channels;
+    /**
+     * @public
+     * @returns {Promise<{data: {[_: string: SpriteDataItem]}, image: HTMLImageElement}>}
+     */
+    public loadSpriteData(): Promise<{
+        data: {
+            [_: string]: SpriteDataItem;
+        };
+    }>;
+    /**
+     * @private
+     * @returns {URL}
+     */
+    private _getSpriteUrlObj;
+    /**
+     * @private
+     * @returns {Promise<{[_: string: SpriteDataItem]}>}
+     */
+    private _loadSpriteJson;
+    /**
+     * @private
+     * @returns {Promise<HTMLImageElement>}
+     */
+    private _loadSpriteImage;
+    /**
+     * @private
+     * @param {{[_: string: SpriteDataItem]}} json
+     * @param {HTMLImageElement} image
+     * @returns {{[_: string: SpriteDataItem]}}
+     */
+    private _generateIconUv;
+    /**
+     * @private
+     * @param {SpriteData} json
+     * @param {ImageData} imageData
+     * @returns {{[id: string: SpriteDataItem]}}
+     */
+    private _generateSpriteData;
+    /**
+     * @private
+     * @param {ImageData} srcImg
+     * @param {RGBAImage} dstImg
+     * @param {{x: number, y: number}} srcPt
+     * @param {{width: number, height: number}} size
+     * @returns {RGBAImage}
+     */
+    private _copyImage;
+    /**
+     * @private
+     * @param {ImageBitmap} imageBitmap
+     * @returns {ImageData}
+     */
+    private _getImageData;
+}
+export type RGBAImage = {
+    width: number;
+    height: number;
+    data: Uint8Array;
+};
+export type SpriteDataItem = {
+    width: number;
+    height: number;
+    data: Uint8Array;
+    pixelRatio: number;
+    stretchX?: Array<Array<number>> | undefined;
+    stretchY?: Array<Array<number>> | undefined;
+    content?: number[] | undefined;
+    sdf?: any | undefined;
+    uvs: number[];
+};

package/dist/types/threemap/mapView/mapbox/style.d.ts

@@ -0,0 +1,25 @@
+export default class MapboxStyle {
+    constructor(styleJSON: any, spec: any, spriteData: any);
+    _styleJSON: any;
+    _spec: any;
+    zoomObject: {
+        zoom: number;
+    } | undefined;
+    functionCache: {} | undefined;
+    filterCache: {} | undefined;
+    featureState: {} | undefined;
+    /**
+     * @public
+     * @type {{[id: string: import('./sprite').SpriteDataItem]}}
+     */
+    public spriteData: {
+        [id: string]: import("./sprite").SpriteDataItem;
+    };
+    setStyleJSON(styleJSON: any): void;
+    getStyleJSON(): any;
+    setSpec(spec: any): void;
+    getSpec(): any;
+    expressionData(rawExpression: any, propertySpec: any): any;
+    getValue(layer: any, layoutOrPaint: any, property: any, zoom: any, feature: any): any;
+    evaluateFilter(layerId: any, filter: any, feature: any, zoom: any): any;
+}

package/dist/types/threemap/mapView/material/ImageryReprojectMaterial.d.ts

@@ -0,0 +1,15 @@
+export class ImageryReprojectMaterial {
+    constructor(parameters?: {});
+    name: string;
+    fragmentShader: string;
+    vertexShader: string;
+    uniforms: {
+        map: {
+            value: null;
+        };
+        color: {
+            value: any;
+        };
+    };
+    dispose(): void;
+}

package/dist/types/threemap/mapView/material/RasterSurfaceMaterial.d.ts

@@ -0,0 +1,15 @@
+export class RasterSurfaceMaterial {
+    constructor(parameters?: {});
+    name: string;
+    fragmentShader: any;
+    vertexShader: any;
+    defines: {
+        NUM_TEXTURES: number;
+    };
+    uniforms: any;
+    updateTextures: (textureConfigs: any, boundRect: any) => void;
+    needsUpdate: boolean | undefined;
+    forceUpdateTextureCount: (textureCount: any) => void;
+    get textureCount(): number;
+    dispose(): void;
+}

package/dist/types/threemap/mapView/material/rasterMaterials.d.ts

@@ -0,0 +1,4 @@
+export function createRasterMaterial(options: any): RasterSurfaceMaterial;
+export function getSharedRasterMaterial(textureCount: any): any;
+export function bindMaterialInfoToMesh(mesh: any, textureConfigs: any, boundRect: any): void;
+import { RasterSurfaceMaterial } from './RasterSurfaceMaterial';

package/dist/types/threemap/mapView/materials/CustomMVTMaterialManager.d.ts

@@ -0,0 +1,9 @@
+export class CustomMVTMaterialManager extends DefaultQuadMapMaterialManager {
+    constructor(config?: {});
+    isCustomMVTMaterialManager: boolean;
+    customConfig: null;
+    addDefaultMaterials(): void;
+    createPbrMaterial: (textureName: any, textureChannels: any, repeat: any, initParameters?: {}, extraParameters?: {}) => any;
+    getTexture: (key: any, type: any, repeat: any, extraParameters: any, callback: any) => any;
+}
+import { DefaultQuadMapMaterialManager } from './DefaultQuadMapMaterialManager';

package/dist/types/threemap/mapView/materials/DarkMVTMaterialManager.d.ts

@@ -0,0 +1,7 @@
+export class DarkMVTMaterialManager extends DefaultQuadMapMaterialManager {
+    isMVTMaterialManager: boolean;
+    /** @private */
+    private _excludeCastShadowMaterials;
+    addDefaultMaterials(): void;
+}
+import { DefaultQuadMapMaterialManager } from './DefaultQuadMapMaterialManager';