vis-core 0.0.1

package/dist/vis/city/objects/plane/Water2.d.ts

@@ -0,0 +1,68 @@
+/**
+ * References:
+ *	https://alex.vlachos.com/graphics/Vlachos-SIGGRAPH10-WaterFlow.pdf
+ *	http://graphicsrunner.blogspot.de/2010/08/water-using-flow-maps.html
+ *
+ */
+export class Water extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
+    constructor(geometry: any, options?: {});
+    isWater: boolean;
+    type: string;
+}
+export namespace Water {
+    namespace WaterShader {
+        let name: string;
+        namespace uniforms {
+            namespace color {
+                let type: string;
+                let value: null;
+            }
+            namespace reflectivity {
+                let type_1: string;
+                export { type_1 as type };
+                let value_1: number;
+                export { value_1 as value };
+            }
+            namespace tReflectionMap {
+                let type_2: string;
+                export { type_2 as type };
+                let value_2: null;
+                export { value_2 as value };
+            }
+            namespace tRefractionMap {
+                let type_3: string;
+                export { type_3 as type };
+                let value_3: null;
+                export { value_3 as value };
+            }
+            namespace tNormalMap0 {
+                let type_4: string;
+                export { type_4 as type };
+                let value_4: null;
+                export { value_4 as value };
+            }
+            namespace tNormalMap1 {
+                let type_5: string;
+                export { type_5 as type };
+                let value_5: null;
+                export { value_5 as value };
+            }
+            namespace textureMatrix {
+                let type_6: string;
+                export { type_6 as type };
+                let value_6: null;
+                export { value_6 as value };
+            }
+            namespace config {
+                let type_7: string;
+                export { type_7 as type };
+                let value_7: Vector4;
+                export { value_7 as value };
+            }
+        }
+        let vertexShader: string;
+        let fragmentShader: string;
+    }
+}
+import { Mesh } from 'three';
+import { Vector4 } from 'three';

package/dist/vis/city/objects/plane/index.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import { BaseObject } from 'gl-draw';
+interface Options {
+    width: number;
+    height: number;
+    material?: THREE.Material;
+    color?: string;
+    map?: THREE.Texture | null;
+}
+export default class extends BaseObject {
+    options: Options;
+    constructor(options: Options);
+    plane: THREE.PlaneGeometry;
+    create(): Promise<void>;
+    addWater(): void;
+    render(): void;
+}
+export {};

package/dist/vis/city/objects/road/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseObject } from 'gl-draw';
+import { Line } from '..';
+interface Options {
+    json: {
+        features: any[];
+    };
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    cacheKey?: string;
+    meters?: number;
+    grey?: boolean;
+    clip?: {
+        features: any[];
+    };
+}
+export default class extends BaseObject {
+    options: Options;
+    constructor(options: Options);
+    outJson: Map<any, any>;
+    linePrimary: Line[];
+    lineSecondary: Line[];
+    create(): Promise<void>;
+    render(): void;
+    dispose(disposeWithMaterial?: boolean): void;
+}
+export {};

package/dist/vis/city/objects/target/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { BaseObject } from 'gl-draw';
+import * as THREE from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+interface Opt {
+    scale?: number;
+}
+export default class extends BaseObject {
+    options: Opt;
+    time: {
+        value: number;
+    };
+    offset: THREE.Vector2;
+    timer: NodeJS.Timeout | null;
+    inTween: TWEEN.Tween<any> | null;
+    outTween: TWEEN.Tween<any> | null;
+    constructor(options: Opt);
+    createWave(color: string): THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+    createRipple(texture: THREE.Texture): THREE.Mesh<THREE.CylinderGeometry, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+    createCylinder(texture: THREE.Texture): THREE.Object3D<THREE.Object3DEventMap>;
+    createTorus(color: string): THREE.Mesh<THREE.TorusGeometry, THREE.MeshBasicMaterial, THREE.Object3DEventMap>;
+    create(): Promise<void>;
+    erase(): void;
+    update(delta: number, elapsed: number): void;
+}
+export {};

package/dist/vis/earth/config.d.ts

@@ -0,0 +1,8 @@
+export declare const IS_DEV: boolean;
+export declare const PENCIL_CONFIG: {
+    camera: {
+        near: number;
+        far: number;
+        fov: number;
+    };
+};

package/dist/vis/earth/index.d.ts

@@ -0,0 +1,28 @@
+import Base from "../Base";
+interface EarthOptions {
+    assetsPrefix?: string;
+}
+export default class extends Base {
+    static VisName: string;
+    drawController: import("gl-draw/dist/plugins").Draw<{
+        Node: typeof import("gl-draw/dist/objects").Node;
+        Image: typeof import("gl-draw/dist/objects").Image;
+        Line: typeof import("gl-draw/dist/objects").Line;
+        ExtrudePolygon: typeof import("gl-draw/dist/objects").ExtrudePolygon;
+        Group: typeof import("gl-draw/dist/objects").Group;
+        Light: typeof import("./objects/light").default;
+        ConicPolygon: typeof import("gl-draw/dist/objects").ConicPolygon;
+        Earth: typeof import("./objects/earth").default;
+        Countries: typeof import("./objects/countries").default;
+        China: typeof import("./objects/china").BorderAreaArc;
+    }>;
+    leftTruck: boolean;
+    options: Required<EarthOptions>;
+    constructor(container: HTMLElement, options?: EarthOptions);
+    loaderAdd(): void;
+    init(): Promise<void>;
+    initEarth(): Promise<void>;
+    show(): void;
+    animationIn(): void;
+}
+export {};

package/dist/vis/earth/objects/china/index.d.ts

@@ -0,0 +1,14 @@
+import { BaseObject } from 'gl-draw';
+import * as THREE from 'three';
+interface Options {
+    borderColor: THREE.Color;
+}
+export declare class BorderAreaArc extends BaseObject {
+    options: Options;
+    constructor(options?: Partial<Options>);
+    create(): Promise<void>;
+    getProvinceByAdcode(adcode: number): import("gl-draw/dist/objects").ConicPolygon | undefined;
+    start(adcode: number): void;
+    end(adcode: number): void;
+}
+export default BorderAreaArc;

package/dist/vis/earth/objects/countries/index.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): Promise<void>;
+}

package/dist/vis/earth/objects/earth/index.d.ts

@@ -0,0 +1,5 @@
+import Sphere from "../../../all/objects/Sphere";
+export default class extends Sphere {
+    radius: number;
+    create(): void;
+}

package/dist/vis/earth/objects/index.d.ts

@@ -0,0 +1,19 @@
+import { Draw as DrawController } from 'gl-draw/dist/plugins';
+import { Node, Image, Line, ExtrudePolygon, Group, ConicPolygon } from 'gl-draw/dist/objects';
+import Earth from './earth';
+import Countries from './countries';
+import Light from './light';
+import China from './china';
+declare const _default: DrawController<{
+    Node: typeof Node;
+    Image: typeof Image;
+    Line: typeof Line;
+    ExtrudePolygon: typeof ExtrudePolygon;
+    Group: typeof Group;
+    Light: typeof Light;
+    ConicPolygon: typeof ConicPolygon;
+    Earth: typeof Earth;
+    Countries: typeof Countries;
+    China: typeof China;
+}>;
+export default _default;

package/dist/vis/earth/objects/light/index.d.ts

@@ -0,0 +1,97 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    bbox: any[];
+    guiParams: {
+        light1: {
+            color: {
+                value: string;
+                target: () => any;
+            };
+            intensity: {
+                value: number;
+                target: () => any;
+            };
+            width: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            height: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            x: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            y: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            z: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+        };
+        light2: {
+            color: {
+                value: string;
+                target: () => any;
+            };
+            intensity: {
+                value: number;
+                target: () => any;
+            };
+            width: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            height: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            x: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            y: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+            z: {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                target: () => any;
+            };
+        };
+    };
+    create(): void;
+}

package/dist/vis/earth/utils/animation.d.ts

@@ -0,0 +1 @@
+export declare const animation: (source: Record<string, any>, target: Record<string, any>, duration?: number, easing?: (amount: number) => number) => Promise<unknown>;

package/dist/vis/earth/utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare const fileLoader: (url: string) => Promise<any>;
+export declare const animation: (source: any, target: any, duration?: number, onUpdate?: (...args: any[]) => void, onComplete?: () => void, ease?: ((amount: number) => number) | undefined) => Promise<void>;

package/dist/vis/earth2/config.d.ts

@@ -0,0 +1,8 @@
+export declare const IS_DEV: boolean;
+export declare const PENCIL_CONFIG: {
+    camera: {
+        near: number;
+        far: number;
+        fov: number;
+    };
+};

package/dist/vis/earth2/index.d.ts

@@ -0,0 +1,36 @@
+import Base from "../Base";
+interface EarthOptions {
+    assetsPrefix?: string;
+}
+export default class extends Base {
+    static VisName: string;
+    leftTruck: boolean;
+    drawController: import("gl-draw/dist/plugins").Draw<{
+        Node: typeof import("gl-draw/dist/objects").Node;
+        Image: typeof import("gl-draw/dist/objects").Image;
+        Line: typeof import("gl-draw/dist/objects").Line;
+        ExtrudePolygon: typeof import("gl-draw/dist/objects").ExtrudePolygon;
+        Group: typeof import("gl-draw/dist/objects").Group;
+        Light: typeof import("../map/objects").Light;
+        ConicPolygon: typeof import("gl-draw/dist/objects").ConicPolygon;
+        Earth: typeof import("./objects/earth").default;
+        Bg: typeof import("./objects/bg").default;
+        Label: typeof import("./objects/label").default;
+        Point: typeof import("./objects/point").default;
+    }>;
+    options: Required<EarthOptions>;
+    constructor(container: HTMLElement, options?: EarthOptions);
+    loaderAdd(): void;
+    init(): Promise<void>;
+    initEarth(): Promise<void>;
+    show(): void;
+    autoRotateSpeed: number;
+    initSettingsObj: {
+        autoRotate: boolean;
+    };
+    handleSetting(key: string, value: boolean): Promise<boolean>;
+    animationIn(): Promise<void>;
+    getLocationPosition(location: [number, number], dr?: number): [number, number, number];
+    dispose(): void;
+}
+export {};

package/dist/vis/earth2/objects/bg/index.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): Promise<void>;
+}

package/dist/vis/earth2/objects/earth/index.d.ts

@@ -0,0 +1,4 @@
+import Sphere from "../../../all/objects/Sphere";
+export default class extends Sphere {
+    create(): void;
+}

package/dist/vis/earth2/objects/index.d.ts

@@ -0,0 +1,21 @@
+import { Draw as DrawController } from 'gl-draw/dist/plugins';
+import { Node, Image, Line, ExtrudePolygon, Group, ConicPolygon } from 'gl-draw/dist/objects';
+import Earth from './earth';
+import Bg from './bg';
+import Label from './label';
+import Point from './point';
+import Light from "../../all/objects/Light";
+declare const _default: DrawController<{
+    Node: typeof Node;
+    Image: typeof Image;
+    Line: typeof Line;
+    ExtrudePolygon: typeof ExtrudePolygon;
+    Group: typeof Group;
+    Light: typeof Light;
+    ConicPolygon: typeof ConicPolygon;
+    Earth: typeof Earth;
+    Bg: typeof Bg;
+    Label: typeof Label;
+    Point: typeof Point;
+}>;
+export default _default;

package/dist/vis/earth2/objects/label/index.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): Promise<void>;
+}

package/dist/vis/earth2/objects/point/index.d.ts

@@ -0,0 +1,17 @@
+import { BaseObject } from 'gl-draw';
+import * as THREE from 'three';
+import { Image } from 'gl-draw/dist/objects';
+interface PointOptions {
+    color?: number | string | THREE.Color;
+}
+export default class extends BaseObject {
+    options: PointOptions;
+    icon: Image;
+    constructor(options: PointOptions);
+    create(): Promise<void>;
+    render(): void;
+    instantiate(): Promise<this>;
+    setColor(color: string): void;
+    setPositon(x: number, y: number, z: number): void;
+}
+export {};

package/dist/vis/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Map } from './map';
+export { default as World } from './map/world';
+export { default as City } from './city';
+export { default as Earth } from './earth';
+export { default as Earth2 } from './earth2';
+export { default as Map2 } from './map2';

package/dist/vis/map/config.d.ts

@@ -0,0 +1,9 @@
+export declare const IS_DEV: boolean;
+export declare const bbox100000: number[];
+export declare const bboxworld: number[];
+export declare const PENCIL_CONFIG: {
+    camera: {
+        near: number;
+        far: number;
+    };
+};

package/dist/vis/map/el.d.ts

@@ -0,0 +1 @@
+export declare const getLabelElement: (name: string) => HTMLDivElement;

package/dist/vis/map/index.d.ts

@@ -0,0 +1,153 @@
+import { BaseObject } from 'gl-draw';
+import Base from "../Base";
+import { getProjection } from 'gl-draw/dist/utils';
+import type { FeatureCollection, Polygon, MultiPolygon } from 'geojson';
+import * as THREE from 'three';
+import { PlaneMap, Group, ContinentsBg } from "./objects";
+import { LevelArr } from 'geojson-cn';
+type GeoJSON = FeatureCollection<Polygon | MultiPolygon>;
+export interface MapOptions {
+    adcode: number;
+    center?: [number, number];
+    parentBg?: boolean | number;
+    bboxOffset?: number[];
+    fixCity?: Record<number, number>;
+    continentsBg?: boolean;
+    continentsBgDepth?: number;
+    clickOusideBack?: boolean;
+    mapDepth?: number[];
+    mapPadding?: number[];
+    geojsonMap?: Record<string, GeoJSON>;
+    extrudeLineGeojsonMap?: Record<string, GeoJSON>;
+    bboxMap?: Record<string, number[]>;
+    lookAtMap?: Record<string, [number, number, number, number, number, number]>;
+    fixGeojson?: Record<string, string>;
+    plateInCenter?: boolean;
+    drillDownPlateInCenter?: boolean;
+    drillDownHideParent?: boolean;
+    drillDownRestrictions?: 'city' | 'district';
+    showDistrict?: boolean;
+    showLabel?: boolean | 'lite';
+    lineWidth?: number;
+    extrudeLineWidth?: number;
+    extrudeLine?: boolean;
+    equirectangular?: boolean;
+    polarAngle?: number;
+    azimuthAngle?: number;
+    assetsPrefix?: string;
+    curvatureResolution?: number;
+    showOneLevel?: boolean;
+    handleBackKeepCamvasState?: boolean;
+}
+export default class extends Base {
+    static VisName: string;
+    drawController: import("gl-draw/dist/plugins").Draw<{
+        Node: typeof import("gl-draw/dist/objects").Node;
+        Image: typeof import("gl-draw/dist/objects").Image;
+        Line: typeof import("gl-draw/dist/objects").Line;
+        PlaneMap: typeof PlaneMap;
+        ContinentsBg: typeof ContinentsBg;
+        ExtrudePolygon: typeof import("gl-draw/dist/objects").ExtrudePolygon;
+        Group: typeof Group;
+        Light: typeof import("./objects").Light;
+        PlaneShadow: typeof import("./objects/PlaneShadow").default;
+    }>;
+    options: Required<MapOptions>;
+    mapHistory: {
+        map?: PlaneMap;
+        mapInfo: LevelArr[0];
+        z: number;
+        cX: number;
+        cY: number;
+        depth: number;
+        cameraPositon?: THREE.Vector3;
+        cameraTarget?: THREE.Vector3;
+    }[];
+    get mapObj(): {
+        map?: PlaneMap | undefined;
+        mapInfo: any;
+        z: number;
+        cX: number;
+        cY: number;
+        depth: number;
+        cameraPositon?: THREE.Vector3 | undefined;
+        cameraTarget?: THREE.Vector3 | undefined;
+    };
+    get map(): PlaneMap | undefined;
+    get mapInfo(): any;
+    get mapArea(): import("gl-draw/dist/objects").ExtrudePolygon[] | undefined;
+    get adcodes(): any[];
+    activePlaneMap: PlaneMap | null;
+    isAnimating: boolean;
+    parentBg: PlaneMap[];
+    continentsBg?: ContinentsBg;
+    group: Group;
+    centroidObj: Record<number, [number, number]>;
+    projection: ReturnType<typeof getProjection>;
+    pcenter: [number, number];
+    pscale: number;
+    meters: number;
+    extendsOptions: Record<string, any>;
+    constructor(container: HTMLElement, options?: MapOptions);
+    initSettingsObj: {
+        label: boolean;
+        labelLite: boolean;
+        shadowMap: boolean;
+    };
+    handleSetting(key: string, value: any): Promise<any>;
+    init(): Promise<void>;
+    initMap(adcode: number): Promise<void>;
+    loaderAdd(adcode: number): void;
+    initMaterial(adcode: number): Promise<void>;
+    setAreaColor(adcode: number, color: string): void;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    shadowMapLight?: BaseObject;
+    shadowMapEnabled(): Promise<void>;
+    shadowMapDisabled(): void;
+    getDepth(adcode: number): number;
+    getAdcodeShowLevel(adcode: number): string;
+    handleClick(e: MouseEvent): void;
+    beforeClickArea(adcodes: number[]): boolean;
+    clickArea({ adcodes, duration, }: {
+        adcodes: number[];
+        duration?: number;
+    }): Promise<void>;
+    drawLabels(): Promise<void>;
+    eraseLabels(): void;
+    geAdcodePosition(adcode: number): number[] | undefined;
+    getLocationPosition(location: [number, number]): number[];
+    getAdcodeScreenPosition(adcode: number): {
+        x: number;
+        y: number;
+    } | undefined;
+    booleanPointInCn(location: [number, number]): boolean;
+    handleDrillDown({ adcode, duration, }: {
+        adcode: number;
+        duration?: number;
+    }): Promise<void>;
+    saveBackCamvasState(index: number): void;
+    fixNear(adcode: number): void;
+    fitTo(obj?: BaseObject, { polarAngle, azimuthAngle, enableTransition, }?: {
+        polarAngle?: number;
+        azimuthAngle?: number;
+        enableTransition?: boolean;
+    }): Promise<void>;
+    paddingInCssPixel(obj: BaseObject, top: number, right: number, bottom: number, left: number, enableTransition: boolean): Promise<void[]>;
+    drawPlaneMap({ geojson, extrudeLineGeojson, bbox, depth, adcode, }: {
+        geojson: GeoJSON;
+        extrudeLineGeojson?: GeoJSON;
+        bbox?: number[];
+        depth: number;
+        adcode: number;
+    }): Promise<PlaneMap>;
+    handleBack(duration?: number): Promise<void>;
+    handleLookBack(duration?: number): Promise<void>;
+    setAdcode({ adcodes, duration }: {
+        adcodes: number[];
+        duration?: number;
+    }): Promise<void>;
+    setPadding(padding: number[]): void;
+    dispose(): void;
+}
+export {};

package/dist/vis/map/objects/ContinentsBg.d.ts

@@ -0,0 +1,26 @@
+import { BaseObject } from 'gl-draw';
+import { PlaneMap } from "./";
+interface Options {
+    scale: number;
+    depth: number;
+    equirectangular: boolean;
+}
+export default class extends BaseObject {
+    options: Options;
+    mapArr: PlaneMap[];
+    constructor(options: Options);
+    create(): Promise<void>;
+    getPointInContinent(location: [number, number]): {
+        type: string;
+        properties: {
+            name: string;
+        };
+        geometry: {
+            type: string;
+            coordinates: number[][][][];
+        };
+    } | undefined;
+    getLocationPosition(location: [number, number]): number[] | undefined;
+    dispose(): void;
+}
+export {};