@soonspacejs/plugin-cps-soonmanager 2.15.14 → 2.15.16

package/dist/resource.utils.d.ts

@@ -0,0 +1 @@
+export declare function appendRetryQuery(url: string): string;

package/dist/semantic-batch.utils.d.ts

@@ -0,0 +1,7 @@
+import { default as SoonSpace } from 'soonspacejs';
+import { SemanticObject } from './semantic.types';
+import { IDetachedSemanticBatchResult, ISemanticCanvasBatch } from './semantic-worker.types';
+export declare function createImmediateSemanticBatches(ssp: SoonSpace, semanticData: SemanticObject, shouldContinue: () => boolean): IDetachedSemanticBatchResult;
+export declare function createDetachedSemanticBatches(ssp: SoonSpace, semanticBatches: ISemanticCanvasBatch[], shouldContinue?: () => boolean): IDetachedSemanticBatchResult;
+export declare function commitDetachedSemanticBatches(ssp: SoonSpace, result: IDetachedSemanticBatchResult): void;
+export declare function disposeDetachedSemanticBatches(ssp: SoonSpace, result: IDetachedSemanticBatchResult): void;

package/dist/semantic-worker.client.d.ts

@@ -0,0 +1,10 @@
+import { ISemanticWorkerConfig } from './semantic-worker.config';
+import { IPreparedSemanticData } from './semantic-worker.types';
+export interface IPrepareSemanticDataInWorkerOptions {
+    sourceUrl?: string;
+    semanticData?: IPreparedSemanticData['semanticData'];
+    config?: ISemanticWorkerConfig;
+    signal?: AbortSignal;
+    workerFactory?: () => Worker;
+}
+export declare function prepareSemanticDataInWorker({ sourceUrl, semanticData, config, signal, workerFactory, }: IPrepareSemanticDataInWorkerOptions): Promise<IPreparedSemanticData>;

package/dist/semantic-worker.config.d.ts

@@ -0,0 +1,28 @@
+export type SemanticCanvasRenderType = 'WALL' | 'COLUMN' | 'WINDOW';
+export declare const SEMANTIC_ROOM_COLOR = "#d9dde3";
+export declare const SEMANTIC_ROOM_OPACITY = 0.18;
+export declare const SEMANTIC_WALL_COLOR = "#64748b";
+export declare const SEMANTIC_WALL_OPACITY = 0.72;
+export declare const SEMANTIC_COLUMN_COLOR = "#52606d";
+export declare const SEMANTIC_COLUMN_OPACITY = 0.78;
+export declare const SEMANTIC_WINDOW_COLOR = "#9bb6c9";
+export declare const SEMANTIC_WINDOW_OPACITY = 0.4;
+export declare const SEMANTIC_WORKER_TRANSPARENT_OPACITY = 0;
+export declare const SEMANTIC_CANVAS_DEPTH_WRITE = true;
+export declare const SEMANTIC_WORKER_TRANSPARENT_DEPTH_WRITE = false;
+export interface ISemanticExteriorRule {
+    maxAdjacentSpaces: number;
+    excludeVirtual?: boolean;
+}
+export interface ISemanticTypeConfig {
+    storyField: string;
+    dataField: string;
+    renderType: SemanticCanvasRenderType;
+    statField: string;
+    exteriorRule?: ISemanticExteriorRule;
+}
+export interface ISemanticWorkerConfig {
+    immediateTypes: ISemanticTypeConfig[];
+    canvasTypes: ISemanticTypeConfig[];
+}
+export declare const DEFAULT_SEMANTIC_WORKER_CONFIG: ISemanticWorkerConfig;

package/dist/semantic-worker.parser.d.ts

@@ -0,0 +1,4 @@
+import { SemanticObject } from './semantic.types';
+import { ISemanticWorkerConfig } from './semantic-worker.config';
+import { IPreparedSemanticData } from './semantic-worker.types';
+export declare function prepareSemanticData(semanticData?: SemanticObject, config?: ISemanticWorkerConfig): IPreparedSemanticData;

package/dist/semantic-worker.shared.d.ts

@@ -0,0 +1,2 @@
+export declare function createSemanticAbortError(reason?: unknown, message?: string): Error;
+export declare function getSemanticErrorMessage(error: unknown): string;

package/dist/semantic-worker.types.d.ts

@@ -0,0 +1,56 @@
+import { SemanticObject } from './semantic.types';
+import { ISemanticWorkerConfig, SemanticCanvasRenderType } from './semantic-worker.config';
+import { BaseObject3D, Canvas3D } from 'soonspacejs';
+export interface ISemanticCanvasDescriptor {
+    id: string;
+    parentId: string;
+    points: Array<{
+        x: number;
+        z: number;
+    }>;
+    yHeight?: number;
+    depth?: number;
+    renderType: SemanticCanvasRenderType;
+    isVirtualWall?: boolean;
+}
+export interface ISemanticCanvasBatch {
+    parentId: string;
+    renderType: SemanticCanvasRenderType;
+    descriptors: ISemanticCanvasDescriptor[];
+}
+export interface ISemanticWorkerStats {
+    walls: number;
+    columns: number;
+    windows: number;
+    exteriorWalls: number;
+    duplicates: number;
+    skipped: number;
+    [key: string]: number;
+}
+export interface IPreparedSemanticData {
+    semanticData: SemanticObject;
+    immediateSemanticData: SemanticObject;
+    semanticBatches: ISemanticCanvasBatch[];
+    stats: ISemanticWorkerStats;
+}
+export interface ISemanticWorkerRequest {
+    requestId: number;
+    sourceUrl?: string;
+    semanticData?: SemanticObject;
+    config?: ISemanticWorkerConfig;
+}
+export interface ISemanticWorkerResponse {
+    requestId: number;
+    result?: IPreparedSemanticData;
+    error?: string;
+}
+export interface IDetachedSemanticBatchResult {
+    batches: IDetachedSemanticBatch[];
+    created: number;
+    skipped: number;
+    cancelled: boolean;
+}
+export interface IDetachedSemanticBatch {
+    parent: BaseObject3D;
+    objects: Canvas3D[];
+}

package/dist/semantic.types.d.ts

@@ -74,6 +74,64 @@ export interface Asset {
     Version: string;
     UBuilder?: any;
 }
+export interface Site {
+    ID?: string;
+    Name?: string;
+    Polygon?: Polygon;
+    Elevation?: number;
+    Coordinates?: number[];
+}
+export interface Zone {
+    ID: string;
+    Name?: string;
+    Polygon?: Polygon;
+    Elevation?: number;
+    Facilities?: number[];
+}
+export interface WaterSource {
+    ID: string;
+    Name?: string;
+    Polygon?: Polygon;
+    Elevation?: number;
+}
+export interface Entrance {
+    ID: string;
+    Name?: string;
+    Width?: number;
+    Thickness?: number;
+    Height?: number;
+    Open?: boolean;
+    RoadEdges?: number[];
+    Polygon?: Polygon;
+    Orientation?: number[];
+    RotationY?: number;
+    Elevation?: number;
+    OutDoor?: boolean;
+}
+export interface RoadName {
+    ID?: string;
+    Name?: string;
+}
+export interface RoadNode {
+    ID: string;
+    Point: number[];
+}
+export interface RoadLane {
+    Width?: number;
+}
+export interface RoadEdge {
+    ID: string;
+    Name: number;
+    Nodes: number[];
+    UpLanes?: RoadLane[];
+    DownLanes?: RoadLane[];
+    Length?: number;
+}
+export interface Roads {
+    Names?: RoadName[];
+    Nodes?: RoadNode[];
+    Edges?: RoadEdge[];
+}
 export interface SemanticObject {
     Buildings?: Building[];
     Doors?: Door[];
@@ -83,5 +141,11 @@ export interface SemanticObject {
     Walls?: Wall[];
     Windows?: Window[];
     Columns?: Column[];
+    Site?: Site;
+    Zones?: Zone[];
+    WaterSources?: WaterSource[];
+    Entrances?: Entrance[];
+    Roads?: Roads;
     Asset?: Asset;
+    asset?: Asset;
 }

package/dist/semantic.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/site-road.utils.d.ts

@@ -0,0 +1,8 @@
+import { default as SoonSpace, BaseObject3D } from 'soonspacejs';
+import { Object3D } from 'three';
+import { IRoadsData, ITreeData } from './types';
+export type SiteRoadRenderResult = {
+    objects: BaseObject3D[];
+};
+export declare function renderSiteAndRoads(ssp: SoonSpace, treeData: ITreeData[], roadsData: IRoadsData, parent: Object3D | null, resolveObjectId: (node: ITreeData) => string): SiteRoadRenderResult;
+export declare function disposeSiteAndRoads(ssp: SoonSpace, result: SiteRoadRenderResult | null): void;

package/dist/types.d.ts

@@ -1,6 +1,9 @@
 import { PlotTextAlign, PlotTextLayoutDirection } from '@soonspacejs/plugin-tiles';
 import { AnimationModeType, BaseObjectInfo, IVector3, PoiNodeType } from 'soonspacejs';
 import { TTweenSource, TTweenType } from 'umanager-animation-parser';
+import { SemanticObject } from './semantic.types';
+import { ISemanticWorkerConfig } from './semantic-worker.config';
+import { ISemanticWorkerStats } from './semantic-worker.types';
 export type BaseTreeNode<T> = T & {
     id: string;
     sid: string;
@@ -10,6 +13,14 @@ export interface IWorkIdMapValue {
     work_id?: string | number | null;
 }
 export type IWorkIdMap = Record<string, IWorkIdMapValue> | Map<string, IWorkIdMapValue>;
+export interface IApplyWorkIdMapResult {
+    received: number;
+    accepted: number;
+    applied: number;
+    pending: number;
+    invalid: number;
+    duplicates: number;
+}
 export interface IGisSettings {
     enabled: boolean;
     longitude: number;
@@ -42,7 +53,7 @@ export interface ITreeData {
     pid: string | null;
     sid: string;
     name: string;
-    renderType: 'GROUP' | '3D' | 'STUB' | 'POLYGON' | 'CIRCLE' | 'WATER_SURFACE' | 'DECAL' | 'AREA' | 'FLOOR' | 'ROOM' | 'DOOR' | 'OUTSIDE' | 'BUILDING' | 'STAIRCASE' | 'ELEVATOR' | 'VENT' | 'WINDOW' | 'GS';
+    renderType: 'GROUP' | '3D' | 'STUB' | 'POLYGON' | 'CIRCLE' | 'WATER_SURFACE' | 'DECAL' | 'AREA' | 'FLOOR' | 'ROOM' | 'DOOR' | 'OUTSIDE' | 'BUILDING' | 'STAIRCASE' | 'ELEVATOR' | 'VENT' | 'WINDOW' | 'ZONE' | 'WATER_SOURCE' | 'ENTRANCE' | 'ROAD' | 'GS';
     deviceCode: string | null;
     matrix: number[];
     familyId: string | null;
@@ -63,6 +74,34 @@ export interface IInnerTreeData extends ITreeData {
     path: string | null;
     children: IInnerTreeData[];
 }
+export interface IRoadLane {
+    width?: number;
+}
+export interface IRoadNode {
+    id: string;
+    sid: string;
+    roadId: string;
+    name?: string;
+    x: number;
+    y: number;
+    z: number;
+    order?: number;
+}
+export interface IRoadEdge {
+    id: string;
+    sid: string;
+    roadId: string;
+    name?: string;
+    startNodeId: string;
+    endNodeId: string;
+    upLanes?: IRoadLane[];
+    downLanes?: IRoadLane[];
+    length?: number;
+}
+export interface IRoadsData {
+    nodes: IRoadNode[];
+    edges: IRoadEdge[];
+}
 export type IFlatData = Pick<ITreeData, 'id' | 'pid' | 'sid' | 'name' | 'renderType' | 'deviceCode' | 'familyId'>;
 export declare enum PoiContentTypeEnum {
     PANEL = "PANEL",
@@ -78,6 +117,31 @@ export interface IProgressEventMap {
         progress: IProgress;
     };
 }
+export type SemanticWorkerStage = 'scene-resource-load' | 'worker-semantic' | 'semantic-fallback-fetch' | 'semantic-fallback-worker-prepare' | 'semantic-fallback-main-prepare' | 'semantic-detached-build' | 'semantic-atomic-commit' | 'scene-paint' | 'scene-matrix-freeze';
+export interface ISemanticWorkerStageEvent {
+    stage: SemanticWorkerStage;
+    status?: 'success' | 'failed' | 'cancelled';
+    [key: string]: unknown;
+}
+export interface ILoadSceneAndSemanticInWorkerOptions {
+    signal?: AbortSignal;
+    shouldContinue?: () => boolean;
+    workerFactory?: () => Worker;
+    semanticConfig?: ISemanticWorkerConfig;
+    freezeSceneWorldMatrix?: boolean;
+    onStage?: (event: ISemanticWorkerStageEvent) => void;
+}
+export interface ILoadSceneAndSemanticInWorkerResult {
+    semanticData: SemanticObject;
+    stats: ISemanticWorkerStats;
+    render: {
+        [key: string]: unknown;
+        renderMode: 'atomic-replacement';
+        progressive: false;
+        hierarchyMode: 'direct-story-child';
+        exteriorFirst: boolean;
+    };
+}
 export interface PoiMedia {
     assetId?: string | null;
     url?: string;
@@ -446,8 +510,12 @@ export interface IGisPlotProperties {
     fillColor: string;
     fillOpacity: number;
     strokeStyle: string;
-    pointStyle: 'circle' | 'square';
+    pointStyle: 'circle' | 'square' | 'image';
     size: number;
+    ontologyId?: string;
+    imageUrl?: string;
+    imageWidth?: number;
+    imageHeight?: number;
     startArrowStyle: string | null;
     endArrowStyle: string | null;
     radius: number;

package/dist/utils.d.ts

@@ -1,4 +1,5 @@
-import { default as SoonSpace, BaseObject3D } from 'soonspacejs';
+import { default as SoonSpace, BaseObject3D, Canvas3D, PlaneIVector2 } from 'soonspacejs';
+import { Object3D } from 'three';
 import { TAnimationFrame } from 'umanager-animation-parser';
 import { BaseTreeNode, IKeyframe, ITreeData } from './types';
 import { default as CpsSoonmanagerPlugin } from '.';
@@ -10,9 +11,9 @@ import { default as CpsSoonmanagerPlugin } from '.';
 export declare function decodeString(encodedStr: string): string;
 export declare const mapTreeNodeByKey: <T, K extends keyof BaseTreeNode<T>, V>(tree: BaseTreeNode<T>[], key: K, map?: Map<V, BaseTreeNode<T>>) => Map<V, BaseTreeNode<T>>;
 export declare function isSpace(renderType: ITreeData['renderType']): renderType is "AREA" | "FLOOR" | "ROOM" | "OUTSIDE" | "BUILDING";
-export declare function createSpace(ssp: SoonSpace, node: ITreeData, objectId: string): import('soonspacejs').Canvas3D;
-export declare function createDoor(ssp: SoonSpace, node: ITreeData, objectId: string): import('soonspacejs').Canvas3D;
-export declare function createWindow(ssp: SoonSpace, node: ITreeData, objectId: string): import('soonspacejs').Canvas3D;
+export declare function createSpace(ssp: SoonSpace, node: ITreeData, objectId: string, transparentSemanticPolygons?: boolean): Canvas3D;
+export declare function createDoor(ssp: SoonSpace, node: ITreeData, objectId: string, transparentSemanticPolygons?: boolean): Canvas3D;
+export declare function createWindow(ssp: SoonSpace, node: ITreeData, objectId: string, transparentSemanticPolygons?: boolean): Canvas3D;
 /**
  * 创建楼梯
  * @param ssp
@@ -20,7 +21,7 @@ export declare function createWindow(ssp: SoonSpace, node: ITreeData, objectId:
  * @param objectId
  * @returns
  */
-export declare function createStaircase(ssp: SoonSpace, node: ITreeData, objectId: string): import('soonspacejs').Canvas3D;
+export declare function createStaircase(ssp: SoonSpace, node: ITreeData, objectId: string, transparentSemanticPolygons?: boolean): Canvas3D;
 /**
  * 创建电梯
  * @param ssp
@@ -28,8 +29,12 @@ export declare function createStaircase(ssp: SoonSpace, node: ITreeData, objectI
  * @param objectId
  * @returns
  */
-export declare function createElevator(ssp: SoonSpace, node: ITreeData, objectId: string): import('soonspacejs').Canvas3D;
+export declare function createElevator(ssp: SoonSpace, node: ITreeData, objectId: string, transparentSemanticPolygons?: boolean): Canvas3D;
 export declare function createWaterSurface(cpsPlugin: CpsSoonmanagerPlugin, node: ITreeData, objectId: string): import('soonspacejs').PluginObject | null;
 export declare function createDecal(ssp: SoonSpace, node: ITreeData, objectId: string, path: string | null): Promise<import('soonspacejs').Decal | null>;
 export declare function createGs3d(ssp: SoonSpace, node: ITreeData, path: string | null): Promise<BaseObject3D>;
 export declare function transformKeyframes(keyframes: IKeyframe[]): TAnimationFrame[];
+export declare function addPolygonOutline(parent: Object3D, name: string, points: PlaneIVector2[], yHeight: number, color: string, lineWidth: number): void;
+export declare function createZone(ssp: SoonSpace, node: ITreeData, objectId: string): Canvas3D;
+export declare function createWaterSource(ssp: SoonSpace, node: ITreeData, objectId: string): Canvas3D;
+export declare function createEntrance(ssp: SoonSpace, node: ITreeData, objectId: string): Canvas3D;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@soonspacejs/plugin-cps-soonmanager",
   "pluginName": "CpsSoonmanagerPlugin",
-  "version": "2.15.14",
+  "version": "2.15.16",
   "description": "Sync cps soonmanager data plugin for SoonSpace.js",
   "main": "dist/index.esm.js",
   "module": "dist/index.esm.js",
@@ -37,14 +37,14 @@
     "socket.io-client": "^4.7.2"
   },
   "peerDependencies": {
-    "@soonspacejs/plugin-atmosphere": "2.15.14",
-    "@soonspacejs/plugin-effect": "2.15.14",
-    "@soonspacejs/plugin-flow": "2.15.14",
-    "@soonspacejs/plugin-gs3d-loader": "2.15.14",
-    "@soonspacejs/plugin-poi-renderer": "2.15.14",
-    "@soonspacejs/plugin-tiles": "2.15.14",
-    "soonspacejs": "2.15.14",
+    "@soonspacejs/plugin-atmosphere": "2.15.16",
+    "@soonspacejs/plugin-effect": "2.15.16",
+    "@soonspacejs/plugin-flow": "2.15.16",
+    "@soonspacejs/plugin-gs3d-loader": "2.15.16",
+    "@soonspacejs/plugin-poi-renderer": "2.15.16",
+    "@soonspacejs/plugin-tiles": "2.15.16",
+    "soonspacejs": "2.15.16",
     "umanager-animation-parser": "^0.0.6",
-    "@soonspacejs/plugin-fds": "2.15.14"
+    "@soonspacejs/plugin-fds": "2.15.16"
   }
 }