@kispace-io/gs-lib 1.1.8 → 1.2.0

package/src/index.ts

@@ -1,10 +1,10 @@
+// Core exports - renderer-agnostic model and utilities
+// For renderer-specific functionality, import from '@kispace-io/gs-lib/ol' or '@kispace-io/gs-lib/ml'
 export * from "./gs-model"
-export * from "./gs-gs2ol"
-export * from "./gs-ol2gs"
-export * from "./gs-ol-adapters"
-export * from "./gs-lib"
-// Re-export OpenLayers for convenience
-export * from "./gs-olns"
+
+// Map renderer interface (no implementation)
+export * from "./map-renderer"
+
 // map-builder is only used by build service - export explicitly to avoid tree-shaking issues
 export { buildMap, generateAppJs, processServiceWorker, processManifest, processHtml, bundleApp, type BuildOptions, type FileSystem, type GsLibFileCopier, type ProgressCallback } from "./base-map-builder"
 
@@ -12,4 +12,9 @@ export const rtUtils = {
     async resolveUrl(url: string) {
         return url
     }
-};
+};
+
+export * from "./ol/index"
+
+// Backward compatibility: export olLib as gsLib for generated build code
+export { olLib as gsLib } from "./ol/gs-ol-lib"

package/src/map-renderer.ts

@@ -0,0 +1,115 @@
+import { GsMap, GsLayer, GsControl, GsOverlay } from "./gs-model";
+
+/**
+ * Sync event types that describe what changed in the map
+ */
+export type MapSyncEvent = 
+    | { type: 'viewChanged', view: { center: [number, number], zoom: number, rotation?: number, pitch?: number, bearing?: number } }
+    | { type: 'featuresChanged', layerUuid: string, features: any[] }
+    | { type: 'featureSelected', layerUuid: string, feature: any, metrics?: { length?: number, area?: number } }
+    | { type: 'featureDeselected' }
+    | { type: 'drawingDisabled' };
+
+/**
+ * Screenshot result from captureScreenshot
+ */
+export type ScreenshotResult = 
+    | { success: true, dataUrl: string, width: number, height: number }
+    | { success: false, error: string };
+
+/**
+ * Abstract interface for map rendering
+ * The host app only knows about this interface and the GsMap domain model
+ * 
+ * This interface is focused purely on rendering and map state management.
+ * For operations, use MapOperations interface instead.
+ */
+export interface MapRenderer {
+    render(container: string | HTMLElement): Promise<void>;
+    reattached?(): Promise<void>;
+    modelToUI(updatedGsMap?: GsMap): Promise<void>;
+    getViewExtent(): Promise<number[]>;
+    getOperations(): MapOperations;
+    setOnDirty(callback: () => void): void;
+    triggerDirty(): void;
+    setOnSync(callback: (event: MapSyncEvent) => void): void;
+    triggerSync(event: MapSyncEvent): void;
+    setOnClick?(callback: () => void): void;
+    captureScreenshot(): Promise<ScreenshotResult>;
+    destroy(): void;
+}
+
+export function findLayerByUuid(gsMap: GsMap, uuid: string): GsLayer | undefined {
+    return gsMap.layers.find(layer => layer.uuid === uuid);
+}
+
+export function findLayerIndexByUuid(gsMap: GsMap, uuid: string): number {
+    return gsMap.layers.findIndex(layer => layer.uuid === uuid);
+}
+
+export function findControlByUuid(gsMap: GsMap, uuid: string): GsControl | undefined {
+    return gsMap.controls.find(control => control.uuid === uuid);
+}
+
+export function findControlIndexByUuid(gsMap: GsMap, uuid: string): number {
+    return gsMap.controls.findIndex(control => control.uuid === uuid);
+}
+
+export function findOverlayByUuid(gsMap: GsMap, uuid: string): GsOverlay | undefined {
+    return gsMap.overlays.find(overlay => overlay.uuid === uuid);
+}
+
+export function findOverlayIndexByUuid(gsMap: GsMap, uuid: string): number {
+    return gsMap.overlays.findIndex(overlay => overlay.uuid === uuid);
+}
+
+/**
+ * Map operations interface for high-level map commands
+ * These operations work with the domain model and are framework-agnostic
+ */
+export interface MapOperations {
+    // View operations
+    setZoom(zoom: number): Promise<void>;
+    setCenter(center: [number, number]): Promise<void>;
+    
+    // Display operations
+    switchColorMode(mode?: 'dark' | 'light'): Promise<void>;
+    
+    // Layer operations
+    addLayer(layer: any, isBasemap?: boolean): Promise<void>;
+    deleteLayer(uuid: string): Promise<void>;
+    renameLayer(uuid: string, newName: string): Promise<void>;
+    moveLayer(uuid: string, targetUuid?: string): Promise<void>;
+    setLayerVisible(uuid: string, visible: boolean): Promise<void>;
+    
+    // Control operations
+    addControlFromModule(src: string): Promise<void>;
+    removeControl(uuid: string): Promise<void>;
+    
+    // Overlay operations
+    addOverlayFromModule(src: string, position?: string): Promise<void>;
+    removeOverlay(uuid: string): Promise<void>;
+    
+    // Drawing operations (UI-only, no domain model changes until features are added)
+    enableDrawing(geometryType: 'Point' | 'LineString' | 'Polygon', layerUuid: string): Promise<void>;
+    disableDrawing(): Promise<void>;
+    
+    // Feature selection and deletion
+    enableFeatureSelection(): Promise<void>;
+    disableSelection(): Promise<void>;
+    deleteSelectedFeatures(): Promise<void>;
+}
+
+export const createProxy = (operations: MapOperations[]): MapOperations => {
+    return new Proxy({}, {
+        get: (_, prop: string) => {
+            return async (...args: any[]) => {
+                // Execute the operation on all registered operations
+                for (const operation of operations) {
+                    await (operation as any)[prop](...args);
+                }
+            };
+        }
+    }) as MapOperations;
+}
+