soonspacejs 2.8.11 → 2.8.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soonspacejs",
-  "version": "2.8.11",
+  "version": "2.8.13",
   "homepage": "http://www.xwbuilders.com:8800/",
   "description": "soonspacejs 2.x",
   "module": "./dist/index.esm.js",
@@ -28,5 +28,5 @@
   "peerDependencies": {
     "three": ">=0.152.2"
   },
-  "gitHead": "7c76a046a116f659fe8fe0f01d0a8451cc370b92"
+  "gitHead": "d5982117927d8f1eccf32efbe1fec6238b7517e6"
 }

package/types/Interface/base.d.ts

@@ -38,7 +38,7 @@ interface BaseSelectOptions {
     color?: IColor;
     opacity?: number;
 }
-interface BaseObjectInfo<ObjectType = Object3D> extends BaseObjectEvents<ObjectType> {
+interface BaseObjectInfo {
     id: string | number;
     name?: string;
     level?: Level;
@@ -48,13 +48,15 @@ interface BaseObjectInfo<ObjectType = Object3D> extends BaseObjectEvents<ObjectT
     scale?: Scale;
     userData?: any;
 }
-interface BaseObjectEvents<ObjectType> {
-    onLoad?: ((object: ObjectType) => void) | null;
-    onClick?: ((object: ObjectType) => void) | null;
-    onDblClick?: ((object: ObjectType) => void) | null;
-    onRightClick?: ((object: ObjectType) => void) | null;
+interface BaseObject3DInfo extends BaseObjectInfo {
+    onLoad?: ((object: Object3D) => void) | null;
+    onClick?: ((object: Object3D) => void) | null;
+    onDblClick?: ((object: Object3D) => void) | null;
+    onRightClick?: ((object: Object3D) => void) | null;
 }
-interface BaseObjectEventsListener {
-    type: 'click' | 'rightClick' | 'dblClick' | string;
+interface ScaleFixed {
+    originScale: number;
+    fixedScale: number;
+    distance: number;
 }
-export { Interpolate, IVector2, IVector3, Position, Rotation, Scale, IColor, PlaneIVector2, Level, OffsetPoint, FlyToViewpoint, AxisType, SceneEventType, SceneEventTypeUppercase, PoiType, PoiNodeType, BaseSelectOptions, BaseObjectEvents, BaseObjectInfo, BaseObjectEventsListener, };
+export { Interpolate, IVector2, IVector3, Position, Rotation, Scale, IColor, PlaneIVector2, Level, OffsetPoint, FlyToViewpoint, AxisType, SceneEventType, SceneEventTypeUppercase, PoiType, PoiNodeType, BaseSelectOptions, BaseObject3DInfo, BaseObjectInfo, ScaleFixed, };

package/types/Interface/manager.d.ts

@@ -1,6 +1,6 @@
 import { Box3, DirectionalLight, HemisphereLight, SpotLight, PointLight, RectAreaLight, Object3D, Light } from 'three';
-import { IColor, IVector2, Position, Rotation, Scale } from './base';
-import { BaseObject3D, BaseObject3DInfo, Canvas3D, Group, Model, ModelInfo, PluginObject, Poi, PoiInfo, PoiNode, Topology } from '../Library';
+import { BaseObjectInfo, IColor, IVector2, Position, Rotation, Scale } from './base';
+import { BaseObject3D, Canvas3D, Group, Model, ModelInfo, PluginObject, Poi, PoiInfo, PoiNode, Topology } from '../Library';
 import { AnimationOptions } from './animation';
 export type ManageCache = {
     objects: Map<BaseObject3D['sid'], Object3D>;
@@ -72,7 +72,7 @@ interface GroupProgressCallback {
 }
 type CloneModelInfo = Omit<ModelInfo, 'url'>;
 type ClonePoiInfo = Omit<PoiInfo, 'url'>;
-interface TopologyInfoForGml extends BaseObject3DInfo {
+interface TopologyInfoForGml extends BaseObjectInfo {
     url: string;
     linkWidth?: number;
     linkColor?: IColor;
@@ -90,21 +90,21 @@ interface TopologyEffectInfo {
     imgUrl?: string;
     animation?: boolean | AnimationOptions;
 }
-interface ShortestPathInfo extends BaseObject3DInfo, TopologyEffectInfo {
+interface ShortestPathInfo extends BaseObjectInfo, TopologyEffectInfo {
     start: Position;
     end: Position;
 }
-interface ShortestPathByMultipleStartPoints extends BaseObject3DInfo, TopologyEffectInfo {
+interface ShortestPathByMultipleStartPoints extends BaseObjectInfo, TopologyEffectInfo {
     start: Position[];
     end: Position;
 }
-interface ShortestPathByMultipleEndPoints extends BaseObject3DInfo, TopologyEffectInfo {
+interface ShortestPathByMultipleEndPoints extends BaseObjectInfo, TopologyEffectInfo {
     start: Position;
     end: Position[];
 }
 interface TopologyPassableInfo {
-    sourceNodeId: BaseObject3DInfo['id'];
-    targetNodeId: BaseObject3DInfo['id'];
+    sourceNodeId: BaseObjectInfo['id'];
+    targetNodeId: BaseObjectInfo['id'];
     passable: number;
 }
 interface TopologyNodeGraph {
@@ -116,8 +116,8 @@ interface TopologyNodeGraph {
     passable: number;
 }
 interface TopologyNodeInfo {
-    id: BaseObject3DInfo['id'];
-    name?: BaseObject3DInfo['name'];
+    id: BaseObjectInfo['id'];
+    name?: BaseObjectInfo['name'];
     position: Position;
     graphs?: TopologyNodeGraph[];
 }

package/types/Interface/viewport.d.ts

@@ -86,6 +86,7 @@ interface ViewportOptions {
     hoverEnabled?: boolean;
     fileCacheEnabled?: boolean;
     levelEnabled?: boolean;
+    scaleFixedEnabled?: boolean;
     closeInfoLog?: boolean;
     closeWarnLog?: boolean;
     useIndexedDB?: boolean;

package/types/Library/BaseMesh.d.ts

@@ -1,14 +1,13 @@
 import { Box3, Vector3, Euler, Mesh, BufferGeometry, Material } from 'three';
 import { Tween } from '@tweenjs/tween.js';
 import { Position, Rotation, Scale, Level, BaseObjectInfo, AnimationOptions } from '../Interface';
-type BaseMeshInfo = BaseObjectInfo<BaseMesh>;
 declare class BaseMesh extends Mesh {
     sid: string | number;
     stype: string;
     handleHide: boolean;
     level: Level;
     isEventPropagation: boolean;
-    constructor(params: BaseMeshInfo, geometry?: BufferGeometry, material?: Material | Material[]);
+    constructor(params?: BaseObjectInfo, geometry?: BufferGeometry, material?: Material | Material[]);
     show(): void;
     hide(): void;
     setMove(position: Position | Vector3, options?: AnimationOptions, onUpdate?: (source: Position, tween: Tween<Position>) => void, onStart?: (tween: Tween<Position>) => void): Promise<void>;
@@ -16,7 +15,6 @@ declare class BaseMesh extends Mesh {
     setScale(scale: Scale | Vector3, options?: AnimationOptions, onUpdate?: (source: Scale, tween: Tween<Scale>) => void, onStart?: (tween: Tween<Scale>) => void): Promise<void>;
     getBoundingBox(): Box3;
     eventPropagation(): void;
-    sClone(recursive?: boolean): BaseMesh;
-    sCopy(source: BaseMesh, recursive?: boolean): BaseMesh;
+    copy(source: this, recursive?: boolean): this;
 }
-export { BaseMesh, BaseMeshInfo, };
+export { BaseMesh, };

package/types/Library/BaseObject3D.d.ts

@@ -1,8 +1,7 @@
-import { Object3D, Vector3, Euler, BaseEvent, Box3 } from 'three';
+import { Object3D, Vector3, Euler, Box3 } from 'three';
 import { Tween } from '@tweenjs/tween.js';
-import { Position, Rotation, Scale, Level, BaseObjectEvents, BaseObjectInfo, BaseObjectEventsListener, AnimationOptions } from '../Interface';
-type BaseObject3DInfo = BaseObjectInfo<BaseObject3D>;
-declare class BaseObject3D<Event extends BaseEvent = BaseObjectEventsListener> extends Object3D<Event> implements BaseObjectEvents<BaseObject3D> {
+import { Position, Rotation, Scale, Level, BaseObject3DInfo, AnimationOptions } from '../Interface';
+declare class BaseObject3D extends Object3D {
     sid: string | number;
     stype: string;
     level: Level;
@@ -12,15 +11,13 @@ declare class BaseObject3D<Event extends BaseEvent = BaseObjectEventsListener> e
     onClick: ((object: any) => void) | null;
     onDblClick: ((object: any) => void) | null;
     onRightClick: ((object: any) => void) | null;
-    constructor(params: BaseObject3DInfo);
+    constructor(params?: BaseObject3DInfo);
     eventPropagation(): void;
     show(): void;
     hide(): void;
     setMove(position: Position | Vector3, options?: AnimationOptions, onUpdate?: (source: Position, tween: Tween<Position>) => void, onStart?: (tween: Tween<Position>) => void): Promise<void>;
     setRotate(rotation: Rotation | Euler, options?: AnimationOptions, onUpdate?: (source: Rotation, tween: Tween<Rotation>) => void, onStart?: (tween: Tween<Rotation>) => void): Promise<void>;
     setScale(scale: Scale | Vector3, options?: AnimationOptions, onUpdate?: (source: Scale, tween: Tween<Scale>) => void, onStart?: (tween: Tween<Scale>) => void): Promise<void>;
-    sClone<T extends BaseObject3D>(recursive?: boolean): T;
-    sCopy<T extends BaseObject3D>(source: BaseObject3D, recursive?: boolean): T;
     getBoundingBox(): Box3;
     getSpaceAttribute(isFromWorld?: boolean): {
         position: Vector3;
@@ -28,5 +25,6 @@ declare class BaseObject3D<Event extends BaseEvent = BaseObjectEventsListener> e
         scale: Vector3;
     };
     syncSpaceAttribute(object: Object3D, isFromWorld?: boolean): void;
+    copy(source: this, recursive?: boolean): this;
 }
-export { BaseObject3D, BaseObject3DInfo, };
+export { BaseObject3D, };

package/types/Library/Canvas3D.d.ts

@@ -1,18 +1,19 @@
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
+import { BaseObjectInfo } from '../Interface';
+import { BaseObject3D } from './BaseObject3D';
 import { BaseMesh } from './BaseMesh';
 import { Point, PointInfo } from './Point';
 import { Line, LineInfo } from './Line';
 import { Polygon, PolygonInfo } from './Polygon';
 import { Circle, CircleInfo } from './Circle';
-interface Canvas3DInfo extends BaseObject3DInfo {
+interface Canvas3DInfo extends BaseObjectInfo {
     points?: PointInfo[];
     lines?: LineInfo[];
     polygons?: PolygonInfo[];
     circles?: CircleInfo[];
 }
 declare class Canvas3D extends BaseObject3D {
-    constructor(params: Canvas3DInfo);
-    create(params: Canvas3DInfo): void;
+    constructor(params?: Canvas3DInfo);
+    create(params?: Canvas3DInfo): void;
     createPoint(params: PointInfo): Point;
     getPoint(id: PointInfo['id']): Point | null;
     removePoint(id: PointInfo['id']): void;
@@ -25,6 +26,6 @@ declare class Canvas3D extends BaseObject3D {
     createCircle(params: CircleInfo): Circle;
     getCircle(id: CircleInfo['id']): Circle | null;
     removeCircle(id: CircleInfo['id']): void;
-    getChildForType<Type extends BaseMesh>(type: Type['stype'], id: Type['sid']): Type | null;
+    getChildForType<Type extends BaseMesh>(type: Type['stype'], id: PointInfo['id']): Type | null;
 }
 export { Canvas3D, Canvas3DInfo, };

package/types/Library/Circle.d.ts

@@ -1,7 +1,7 @@
-import { IColor } from '../Interface';
-import { BaseMesh, BaseMeshInfo } from './BaseMesh';
+import { BaseObjectInfo, IColor } from '../Interface';
+import { BaseMesh } from './BaseMesh';
 import { GradientTextureOptions } from '../Shared';
-interface CircleInfo extends BaseMeshInfo {
+interface CircleInfo extends BaseObjectInfo {
     radius?: number;
     color?: IColor;
     opacity?: number;
@@ -9,7 +9,7 @@ interface CircleInfo extends BaseMeshInfo {
 }
 type SetOptionsCircleInfo = Omit<CircleInfo, 'id'>;
 declare class Circle extends BaseMesh {
-    constructor(params: CircleInfo);
+    constructor(params?: CircleInfo);
     setOptions(params: SetOptionsCircleInfo): void;
 }
 export { Circle, CircleInfo, SetOptionsCircleInfo, };

package/types/Library/Ground.d.ts

@@ -1,7 +1,8 @@
-import { BaseMesh, BaseMeshInfo } from './BaseMesh';
 import { BufferGeometry, Material } from 'three';
-type GroundInfo = BaseMeshInfo;
+import { BaseObjectInfo } from '../Interface';
+import { BaseMesh } from './BaseMesh';
+type GroundInfo = BaseObjectInfo;
 declare class Ground extends BaseMesh {
-    constructor(params: GroundInfo, geometry?: BufferGeometry, material?: Material);
+    constructor(params?: BaseObjectInfo, geometry?: BufferGeometry, material?: Material);
 }
 export { Ground, GroundInfo, };

package/types/Library/Group.d.ts

@@ -1,7 +1,8 @@
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
-type GroupInfo = BaseObject3DInfo;
+import { BaseObjectInfo } from '../Interface';
+import { BaseObject3D } from './BaseObject3D';
+type GroupInfo = BaseObjectInfo;
 declare class Group extends BaseObject3D {
-    constructor(params: GroupInfo);
+    constructor(params?: GroupInfo);
     showAllChild(): void;
     hideAllChild(): void;
 }

package/types/Library/Icon.d.ts

@@ -7,6 +7,6 @@ interface IconInfo {
 }
 declare class Icon extends Sprite {
     stype: string;
-    constructor(material: SpriteMaterial, params?: IconInfo);
+    constructor(material?: SpriteMaterial, params?: IconInfo);
 }
 export { Icon, IconInfo, };

package/types/Library/Line.d.ts

@@ -1,7 +1,7 @@
 import { GradientTextureOptions } from '../Shared';
-import { Position, IColor } from '../Interface';
-import { BaseMesh, BaseMeshInfo } from './BaseMesh';
-interface LineInfo extends BaseMeshInfo {
+import { Position, IColor, BaseObjectInfo } from '../Interface';
+import { BaseMesh } from './BaseMesh';
+interface LineInfo extends BaseObjectInfo {
     points: Position[];
     width?: number;
     color?: IColor;
@@ -11,8 +11,8 @@ interface LineInfo extends BaseMeshInfo {
 type SetOptionsLineInfo = Omit<LineInfo, 'id'>;
 declare class Line extends BaseMesh {
     points: Position[];
-    params: LineInfo;
-    constructor(params: LineInfo);
+    params?: LineInfo;
+    constructor(params?: LineInfo);
     setOptions(params: SetOptionsLineInfo): void;
 }
 export { Line, LineInfo, SetOptionsLineInfo, };

package/types/Library/Link.d.ts

@@ -1,7 +1,7 @@
 import { BufferGeometry, MeshStandardMaterial, Vector3, Texture } from 'three';
-import { Position, IColor } from '../Interface';
-import { BaseMesh, BaseMeshInfo } from './BaseMesh';
-interface LinkInfo extends BaseMeshInfo {
+import { Position, IColor, BaseObjectInfo } from '../Interface';
+import { BaseMesh } from './BaseMesh';
+interface LinkInfo extends BaseObjectInfo {
     passable?: number;
     start: Position;
     end: Position;
@@ -11,11 +11,11 @@ interface LinkInfo extends BaseMeshInfo {
     imgUrl?: string;
 }
 declare class Link extends BaseMesh {
-    readonly params: LinkInfo;
+    readonly params?: LinkInfo | undefined;
     geometry: BufferGeometry<import("three").NormalBufferAttributes>;
     material: MeshStandardMaterial;
     passable: number;
-    constructor(params: LinkInfo);
+    constructor(params?: LinkInfo | undefined);
     updateGeometry(params: Pick<LinkInfo, 'start' | 'end'>): void;
     computeVertex(up?: Vector3): void;
     computeTextureRepeat(texture: Texture): void;

package/types/Library/Model.d.ts

@@ -1,5 +1,6 @@
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
 import { ModelFormat } from '../Constants';
+import { BaseObject3DInfo } from '../Interface';
+import { BaseObject3D } from './BaseObject3D';
 interface ModelInfo extends BaseObject3DInfo {
     url: string;
     format?: ModelFormat;
@@ -8,12 +9,12 @@ interface ModelInnerInfo extends ModelInfo {
     format: ModelFormat;
 }
 declare class Model extends BaseObject3D {
-    readonly formatType: ModelFormat;
-    readonly url: string;
-    constructor(params: ModelInnerInfo);
+    formatType?: ModelFormat;
+    url?: string;
+    constructor(params?: ModelInnerInfo);
     setEnvMap(dirPath: string, fileNames?: string[], options?: {
         reflectivity?: number;
     }): void;
-    sClone<T extends BaseObject3D>(recursive?: boolean): T;
+    copy(source: this, recursive?: boolean): this;
 }
 export { Model, ModelInfo, ModelInnerInfo, };

package/types/Library/Node.d.ts

@@ -5,6 +5,6 @@ interface NodeInfo extends PointInfo {
 }
 declare class Node extends Point {
     graphs: TopologyNodeGraph[];
-    constructor(params: NodeInfo);
+    constructor(params?: NodeInfo);
 }
 export { Node, NodeInfo, };

package/types/Library/PluginObject.d.ts

@@ -1,6 +1,7 @@
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
-type PluginObjectInfo = BaseObject3DInfo;
+import { BaseObjectInfo } from '../Interface';
+import { BaseObject3D } from './BaseObject3D';
+type PluginObjectInfo = BaseObjectInfo;
 declare class PluginObject extends BaseObject3D {
-    constructor(params: PluginObjectInfo);
+    constructor(params?: PluginObjectInfo);
 }
 export { PluginObject, PluginObjectInfo, };

package/types/Library/Poi.d.ts

@@ -1,41 +1,33 @@
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
-import { Icon, IconInfo } from './Icon';
-import { SpriteMaterial, Box3 } from 'three';
-import { ClonePoiInfo, IVector3, PoiType } from '../Interface';
+import { BaseObject3D } from './BaseObject3D';
+import { Icon } from './Icon';
+import { Box3 } from 'three';
+import { BaseObject3DInfo, IVector3, PoiType, ScaleFixed } from '../Interface';
 interface PoiInfo extends BaseObject3DInfo {
     url: string;
     type?: PoiType;
     namePosition?: IVector3;
     nameScale?: IVector3;
-    scaleFixed?: {
-        originScale: number;
-        fixedScale: number;
-        distance: number;
-    };
+    nameCanvasInfo?: NameCanvasInfo;
+    iconScale?: IVector3;
+    scaleFixed?: ScaleFixed;
 }
-interface CanvasTextInfo {
-    fontFamily?: string;
-    fontSize?: number;
-    color?: string;
+interface NameCanvasInfo {
+    font?: string;
+    fillStyle?: CanvasFillStrokeStyles['fillStyle'];
+    strokeStyle?: CanvasFillStrokeStyles['strokeStyle'];
     textAlign?: CanvasTextAlign;
     textBaseline?: CanvasTextBaseline;
 }
 declare class Poi extends BaseObject3D {
-    readonly params: PoiInfo;
-    readonly iconType: PoiType;
-    icon: Icon;
-    text: Icon | null;
+    icon?: Icon;
+    text?: Icon;
+    iconType?: PoiType;
     /**
      * scale 锁定
      */
     scaleFixed: PoiInfo['scaleFixed'];
-    constructor(material: SpriteMaterial, params: PoiInfo);
+    constructor(params?: PoiInfo);
     getBoundingBox(padding?: number): Box3;
-    sClone<T extends BaseObject3D>(recursive?: boolean, params?: ClonePoiInfo): T;
-    _createIcon(material: SpriteMaterial): Icon;
-    _createText(info: IconInfo): Icon;
-    _createTextMaterial(info: IconInfo): SpriteMaterial;
-    _createTextCanvas(text: string, info?: CanvasTextInfo): HTMLCanvasElement;
-    _computeMaterialSizeAttenuation(material: SpriteMaterial): SpriteMaterial;
+    copy(source: this, recursive?: boolean): this;
 }
-export { Poi, PoiInfo, CanvasTextInfo, };
+export { Poi, PoiInfo, NameCanvasInfo, };

package/types/Library/PoiNode.d.ts

@@ -1,23 +1,23 @@
 import { Box3 } from 'three';
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
-import { PoiNodeType } from '../Interface';
+import { BaseObject3D } from './BaseObject3D';
+import { BaseObject3DInfo, PoiNodeType, ScaleFixed } from '../Interface';
 interface PoiNodeInfo extends BaseObject3DInfo {
     type: PoiNodeType;
     element: HTMLElement;
     elementAutoDisplay?: boolean;
     occlude?: boolean;
     onChange?: (visible: boolean) => void;
+    scaleFixed?: ScaleFixed;
 }
 declare class PoiNode extends BaseObject3D {
-    readonly elementType: PoiNodeInfo['type'];
-    readonly element: PoiNodeInfo['element'];
-    readonly elementAutoDisplay: PoiNodeInfo['elementAutoDisplay'];
-    readonly occlude: PoiNodeInfo['occlude'];
-    readonly onChange: PoiNodeInfo['onChange'];
-    constructor(params: PoiNodeInfo);
+    readonly elementType?: PoiNodeInfo['type'];
+    readonly element?: PoiNodeInfo['element'];
+    elementAutoDisplay: PoiNodeInfo['elementAutoDisplay'];
+    occlude: PoiNodeInfo['occlude'];
+    onChange: PoiNodeInfo['onChange'];
+    scaleFixed: PoiNodeInfo['scaleFixed'];
+    constructor(params?: PoiNodeInfo);
     create(type: PoiNodeInfo['type']): void;
-    show(): void;
-    hide(): void;
     getBoundingBox(padding?: number): Box3;
     _create2D(): void;
     _create2DHalf(): void;

package/types/Library/Point.d.ts

@@ -1,7 +1,7 @@
-import { BaseMesh, BaseMeshInfo } from './BaseMesh';
-import { IColor } from '../Interface';
+import { BaseMesh } from './BaseMesh';
+import { BaseObjectInfo, IColor } from '../Interface';
 import { GradientTextureOptions } from '../Shared';
-interface PointInfo extends BaseMeshInfo {
+interface PointInfo extends BaseObjectInfo {
     radius?: number;
     color?: IColor;
     opacity?: number;
@@ -9,7 +9,7 @@ interface PointInfo extends BaseMeshInfo {
 }
 type SetOptionsPointInfo = Omit<PointInfo, 'id'>;
 declare class Point extends BaseMesh {
-    constructor(params: PointInfo);
+    constructor(params?: PointInfo);
     setOptions(params: SetOptionsPointInfo): void;
 }
 export { Point, PointInfo, SetOptionsPointInfo, };

package/types/Library/Polygon.d.ts

@@ -1,7 +1,7 @@
-import { IColor, PlaneIVector2 } from '../Interface';
-import { BaseMesh, BaseMeshInfo } from './BaseMesh';
+import { BaseObjectInfo, IColor, PlaneIVector2 } from '../Interface';
+import { BaseMesh } from './BaseMesh';
 import { GradientTextureOptions } from '../Shared';
-interface PolygonInfo extends BaseMeshInfo {
+interface PolygonInfo extends BaseObjectInfo {
     yHeight: number;
     points: PlaneIVector2[];
     color?: IColor;
@@ -11,7 +11,7 @@ interface PolygonInfo extends BaseMeshInfo {
 type SetOptionsPolygonInfo = Omit<PolygonInfo, 'id'>;
 declare class Polygon extends BaseMesh {
     points: PlaneIVector2[];
-    constructor(params: PolygonInfo);
+    constructor(params?: PolygonInfo);
     setOptions(params: SetOptionsPolygonInfo): void;
 }
 export { Polygon, PolygonInfo, SetOptionsPolygonInfo, };

package/types/Library/Topology.d.ts

@@ -1,15 +1,15 @@
 import { Tween } from '@tweenjs/tween.js';
-import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
+import { BaseObject3D } from './BaseObject3D';
 import { Node, NodeInfo } from './Node';
 import { Circle, CircleInfo } from './Circle';
 import { Link, LinkInfo } from './Link';
-import { TopologyNodeInfo, TopologyEffectInfo, TopologyInnerNodeInfo, IVector2, TopologyNodeGraph } from '../Interface';
+import { TopologyNodeInfo, TopologyEffectInfo, TopologyInnerNodeInfo, IVector2, BaseObjectInfo, TopologyNodeGraph } from '../Interface';
 type TopologyType = 'line' | 'network';
-interface TopologyInfo extends BaseObject3DInfo, TopologyEffectInfo {
+interface TopologyInfo extends BaseObjectInfo, TopologyEffectInfo {
     nodes: TopologyNodeInfo[];
     type: TopologyType;
 }
-interface TopologyInnerInfo extends BaseObject3DInfo, TopologyEffectInfo {
+interface TopologyInnerInfo extends BaseObjectInfo, TopologyEffectInfo {
     nodes: TopologyInnerNodeInfo[];
     type: TopologyType;
 }
@@ -20,7 +20,7 @@ declare class Topology extends BaseObject3D {
     links: Link[];
     linksImgAnimation: Tween<IVector2> | null;
     info: TopologyInnerInfo;
-    constructor(params: TopologyInnerInfo);
+    constructor(params?: TopologyInnerInfo);
     create(): void;
     createNode(params: NodeInfo): Node;
     createCircle(params: CircleInfo): Circle;

package/types/Manager/DefaultManage.d.ts

@@ -1,11 +1,12 @@
-import { Object3D, Scene } from 'three';
+import { Object3D } from 'three';
 import Viewport from '../Viewport';
 import { Group, GroupInfo, BaseObject3D } from '../Library';
 declare class DefaultManage {
     readonly type: string;
     readonly viewport: Viewport;
-    readonly scene: Scene;
-    constructor(type: string, viewport: Viewport);
+    readonly objectsCache: Set<Object3D>;
+    readonly scene: import("three").Scene;
+    constructor(type: string, viewport: Viewport, objectsCache: Set<Object3D>);
     /***
      * group
      */

package/types/Manager/PoiManage.d.ts

@@ -1,18 +1,24 @@
-import { SpriteMaterial } from 'three';
+import { SpriteMaterial, Texture } from 'three';
 import DefaultManage from './DefaultManage';
-import { Poi, PoiInfo, Group, GroupInfo, BaseObject3D } from '../Library';
-import { ClonePoiInfo, ManageCache } from '../Interface';
+import { Poi, PoiInfo, Group, GroupInfo, BaseObject3D, Icon, NameCanvasInfo } from '../Library';
+import { ClonePoiInfo, ManageCache, PoiType } from '../Interface';
 import Viewport from '../Viewport';
 declare class PoiManage extends DefaultManage {
     readonly viewport: Viewport;
     readonly cache: ManageCache;
-    materials: Map<string, SpriteMaterial>;
+    textures: Map<string, Texture>;
     constructor(viewport: Viewport, cache: ManageCache);
+    _createIcon(info: PoiInfo): Icon;
+    _createText(info: ClonePoiInfo): Icon;
+    _createTextMaterial(info: ClonePoiInfo): SpriteMaterial;
+    _createTextCanvas(text: string, info?: NameCanvasInfo): HTMLCanvasElement;
+    _computeMaterialSizeAttenuation(material: SpriteMaterial, iconType?: PoiType): SpriteMaterial;
+    protected _create(info: PoiInfo): Poi;
     create(info: PoiInfo): Poi;
     clone(poi: Poi, poiInfo: ClonePoiInfo, parent?: BaseObject3D | null): Poi | void;
     createToGroup(groupInfo: GroupInfo, poiInfo: PoiInfo[]): Group;
     addForGroup(group: Group | null, poiInfo: PoiInfo[]): Group | null;
-    _createMaterial(url: PoiInfo['url']): SpriteMaterial;
+    _createIconMaterial({ url, type, }: PoiInfo): SpriteMaterial;
     private _copyMaterial;
 }
 export default PoiManage;

package/types/Manager/index.d.ts

@@ -43,6 +43,10 @@ declare class Manager {
      * @returns
      */
     levelUpdate(): void;
+    /**
+     * scale fixed
+     */
+    scaleFixedUpdate(): void;
     /**
      *
      * frame update

package/types/Math/dijkstra/index.d.ts

@@ -1,4 +1,4 @@
-import { BaseObject3DInfo } from '../../Library';
+import { BaseObjectInfo } from '../../Interface';
 import { MinHeap } from '../../Shared';
 /**
 * Javascript implementation of Dijkstra's algorithm
@@ -19,7 +19,7 @@ import { MinHeap } from '../../Shared';
 *	const path = d.getPath('A', 'D');
 *
 */
-type BaseId = BaseObject3DInfo['id'];
+type BaseId = BaseObjectInfo['id'];
 type Graph = Map<BaseId, Map<BaseId, number>>;
 type InputGraph = [BaseId, [BaseId, number][]][];
 declare class Dijkstras {

package/types/Shared/MinHeap.d.ts

@@ -1,5 +1,5 @@
-import { BaseObject3DInfo } from '../Library';
-type BaseId = BaseObject3DInfo['id'];
+import { BaseObjectInfo } from '../Interface';
+type BaseId = BaseObjectInfo['id'];
 interface MinHeapNode {
     nodeIndex: BaseId;
     distance: number;

package/types/Shared/viewport.d.ts

@@ -1,4 +1,4 @@
-import { Vector3, Euler, Box3, Object3D, Vector2 } from 'three';
+import { Vector3, Euler, Box3, Object3D, Vector2, Camera } from 'three';
 import { IVector3, AxisType } from '../Interface';
 declare function IVector3ToVector3(val: IVector3 | Vector3): Vector3;
 declare function IVector3ToEuler(val: IVector3 | Euler): Euler;
@@ -31,5 +31,5 @@ declare function getSpaceAttributeFromObject(object: Object3D, isFromWorld?: boo
  */
 declare function syncSpaceAttributeToObject(target: Object3D, source: Object3D, isFromWorld?: boolean): void;
 declare function isObjectVisible(object: Object3D): boolean;
-declare const calculateScaleFactor: (point3: THREE.Vector3, radiusPx: number, camera: THREE.Camera, size: Vector2) => number;
+declare const calculateScaleFactor: (point3: Vector3, radiusPx: number, camera: Camera, size: Vector2) => number;
 export { IVector3ToVector3, IVector3ToEuler, getBoundingBox, rotationAxisFix, rotationAFix, deg2Euler, euler2Deg, getSpaceAttributeFromObject, syncSpaceAttributeToObject, isObjectVisible, calculateScaleFactor, };