@kispace-io/gs-lib 0.0.0

package/dist/pwa/manifest.json

@@ -0,0 +1,54 @@
+{
+  "id": "/",
+  "scope": "/",
+  "name": "$PWA_NAME",
+  "display": "standalone",
+  "start_url": "/",
+  "short_name": "$PWA_SHORT_NAME",
+  "description": "$PWA_DESCRIPTION",
+  "version": "$PWA_VERSION",
+  "orientation": "any",
+  "related_applications": [],
+  "prefer_related_applications": false,
+  "display_override": [
+    "window-controls-overlay"
+  ],
+  "launch_handler": {
+    "client_mode": "focus-existing"
+  },
+  "icons": [
+    {
+      "src": "assets/icons/512x512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    },
+    {
+      "src": "assets/icons/192x192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "assets/icons/48x48.png",
+      "sizes": "48x48",
+      "type": "image/png"
+    },
+    {
+      "src": "assets/icons/24x24.png",
+      "sizes": "24x24",
+      "type": "image/png"
+    }
+  ],
+  "screenshots": [],
+  "features": [
+    "Cross Platform",
+    "fast",
+    "interactive"
+  ],
+  "categories": [
+    "mapping",
+    "geospatial",
+    "interaction"
+  ],
+  "shortcuts": [],
+  "widgets": []
+}

package/dist/pwa/staticwebapp.config.json

@@ -0,0 +1,6 @@
+{
+  "navigationFallback": {
+    "rewrite": "index.html",
+    "exclude": ["*.{css,js,mjs,ts,png,gif,ico,jpg,svg,json,woff2,ttf}"]
+  }
+}

package/dist/pwa/sw.js

@@ -0,0 +1,109 @@
+importScripts(
+    'https://storage.googleapis.com/workbox-cdn/releases/7.3.0/workbox-sw.js'
+);
+
+// Version management for PWA updates
+const CACHE_VERSION = '$PWA_VERSION';
+const CACHE_NAME = `geospace-v${CACHE_VERSION}`;
+
+// This is your Service Worker, you can put any of your custom Service Worker
+// code in this file, above the `precacheAndRoute` line.
+
+// When widget is installed/pinned, push initial state.
+self.addEventListener('widgetinstall', (event) => {
+    event.waitUntil(updateWidget(event));
+});
+
+// When widget is shown, update content to ensure it is up-to-date.
+self.addEventListener('widgetresume', (event) => {
+    event.waitUntil(updateWidget(event));
+});
+
+// When the user clicks an element with an associated Action.Execute,
+// handle according to the 'verb' in event.action.
+self.addEventListener('widgetclick', (event) => {
+if (event.action == "updateName") {
+    event.waitUntil(updateName(event));
+}
+});
+
+// When the widget is uninstalled/unpinned, clean up any unnecessary
+// periodic sync or widget-related state.
+self.addEventListener('widgetuninstall', (event) => {});
+
+// Handle service worker updates and version changes
+self.addEventListener('install', (event) => {
+    console.log(`Service Worker installing version ${CACHE_VERSION}`);
+    // Skip waiting to activate immediately
+    self.skipWaiting();
+});
+
+self.addEventListener('activate', (event) => {
+    console.log(`Service Worker activating version ${CACHE_VERSION}`);
+    event.waitUntil(
+        // Clean up old caches
+        caches.keys().then((cacheNames) => {
+            return Promise.all(
+                cacheNames.map((cacheName) => {
+                    // Delete caches that don't match current version
+                    if (cacheName.startsWith('geospace-v') && cacheName !== CACHE_NAME) {
+                        console.log(`Deleting old cache: ${cacheName}`);
+                        return caches.delete(cacheName);
+                    }
+                })
+            );
+        }).then(() => {
+            // Take control of all clients immediately
+            return self.clients.claim().then(() => {
+                // Notify all clients about the new version
+                return self.clients.matchAll().then(clients => {
+                    clients.forEach(client => {
+                        client.postMessage({
+                            type: 'RELOAD',
+                            version: CACHE_VERSION
+                        });
+                    });
+                });
+            });
+        })
+    );
+});
+
+// Handle version change notifications
+self.addEventListener('message', (event) => {
+    if (event.data && event.data.type === 'SKIP_WAITING') {
+        self.skipWaiting();
+    }
+});
+
+const updateWidget = async (event) => {
+// The widget definition represents the fields specified in the manifest.
+    const widgetDefinition = event.widget.definition;
+
+    // Fetch the template and data defined in the manifest to generate the payload.
+    const payload = {
+        template: JSON.stringify(await (await fetch(widgetDefinition.msAcTemplate)).json()),
+        data: JSON.stringify(await (await fetch(widgetDefinition.data)).json()),
+    };
+
+    // Push payload to widget.
+    await self.widgets.updateByInstanceId(event.instanceId, payload);
+}
+
+const updateName = async (event) => {
+    const name = event.data.json().name;
+
+    // The widget definition represents the fields specified in the manifest.
+    const widgetDefinition = event.widget.definition;
+
+    // Fetch the template and data defined in the manifest to generate the payload.
+    const payload = {
+        template: JSON.stringify(await (await fetch(widgetDefinition.msAcTemplate)).json()),
+        data: JSON.stringify({name}),
+    };
+
+    // Push payload to widget.
+    await self.widgets.updateByInstanceId(event.instanceId, payload);
+}
+
+workbox.precaching.precacheAndRoute(self.__WB_MANIFEST || []);

package/lib/node-map-builder.ts

@@ -0,0 +1,200 @@
+// Dynamic imports for Node.js modules to avoid bundling in browser builds
+import {
+    BuildOptions,
+    FileSystem,
+    ProgressCallback,
+    buildMap,
+    calculateTotalSteps,
+    createCopyAssetsFunction
+} from '../src/base-map-builder'
+import {GsMap} from '../src/gs-model'
+
+/**
+ * Create a Node.js file system implementation
+ */
+export async function createNodeFileSystem(projectRoot: string): Promise<FileSystem> {
+    // Dynamic imports to avoid bundling Node.js modules in browser builds
+    const path = await import('path')
+    const fs = await import('fs/promises')
+    
+    return {
+        async readFile(filePath: string): Promise<string | Uint8Array> {
+            const fullPath = path.resolve(projectRoot, filePath)
+            return await fs.readFile(fullPath)
+        },
+        async writeFile(filePath: string, content: string | Uint8Array): Promise<void> {
+            const fullPath = path.resolve(projectRoot, filePath)
+            await fs.mkdir(path.dirname(fullPath), { recursive: true })
+            await fs.writeFile(fullPath, content)
+        },
+        async ensureDir(dirPath: string): Promise<void> {
+            const fullPath = path.resolve(projectRoot, dirPath)
+            await fs.mkdir(fullPath, { recursive: true })
+        },
+        async exists(filePath: string): Promise<boolean> {
+            const fullPath = path.resolve(projectRoot, filePath)
+            try {
+                await fs.access(fullPath)
+                return true
+            } catch {
+                return false
+            }
+        },
+        async deleteDir(dirPath: string): Promise<void> {
+            const fullPath = path.resolve(projectRoot, dirPath)
+            await fs.rm(fullPath, { recursive: true, force: true })
+        }
+    }
+}
+
+/**
+ * Create an esbuild plugin that resolves modules from a Node.js file system
+ */
+export async function createNodeResolvePlugin(projectRoot: string, gsLibPath: string): Promise<any> {
+    // Dynamic imports to avoid bundling Node.js modules in browser builds
+    const path = await import('path')
+    const fs = await import('fs/promises')
+    const esbuild = await import('esbuild')
+    
+    return {
+        name: 'node-resolve',
+        setup(build: any) {
+            build.onResolve({ filter: /.*/ }, (args: any) => {
+                // Skip external URLs
+                if (args.path.startsWith('http://') || args.path.startsWith('https://')) {
+                    return
+                }
+                
+                let resolvedPath = args.path
+                
+                // Resolve @kispace-io/gs-lib to the provided path
+                if (args.path === '@kispace-io/gs-lib') {
+                    return { path: path.resolve(projectRoot, gsLibPath), namespace: 'file' }
+                }
+                if (args.path.startsWith('@kispace-io/gs-lib/')) {
+                    const subpath = args.path.replace('@kispace-io/gs-lib/', '')
+                    return { path: path.resolve(projectRoot, gsLibPath.replace('index.js', subpath)), namespace: 'file' }
+                }
+                
+                // Handle relative paths
+                if (args.path.startsWith('./') || args.path.startsWith('../')) {
+                    if (args.importer) {
+                        const importerDir = path.dirname(args.importer)
+                        resolvedPath = path.resolve(importerDir, args.path)
+                    } else {
+                        resolvedPath = path.resolve(projectRoot, args.path)
+                    }
+                } else if (!path.isAbsolute(args.path)) {
+                    // Bare specifier - resolve relative to project root
+                    resolvedPath = path.resolve(projectRoot, args.path)
+                }
+                
+                return { path: resolvedPath, namespace: 'file' }
+            })
+            
+            build.onLoad({ filter: /.*/, namespace: 'file' }, async (args: any) => {
+                try {
+                    const contents = await fs.readFile(args.path, 'utf-8')
+                    const ext = path.extname(args.path)
+                    const loader = ext === '.ts' ? 'ts' : ext === '.js' ? 'js' : ext === '.json' ? 'json' : 'js'
+                    return { contents, loader }
+                } catch (error: any) {
+                    throw new Error(`Failed to load ${args.path}: ${error.message}`)
+                }
+            })
+        }
+    }
+}
+
+
+/**
+ * Build a complete .geospace project for CI/CD
+ * This function can be used in Node.js without geospace or appspace packages
+ * 
+ * @param projectRoot - Root directory of the .geospace project
+ * @param mapFile - Path to the .geospace map file (relative to projectRoot)
+ * @param options - Build configuration options
+ * @param progress - Optional progress callback
+ */
+export async function buildProject(
+    projectRoot: string,
+    mapFile: string,
+    options: {
+        title?: string,
+        version?: string,
+        env?: Record<string, string>,
+        gsLibPackagePath?: string,
+        outputDir?: string,
+        cleanAfterBuild?: boolean
+    } = {},
+    progress?: ProgressCallback
+): Promise<void> {
+    const {
+        title,
+        version,
+        env,
+        gsLibPackagePath,
+        outputDir,
+        cleanAfterBuild
+    } = options
+    
+    if (!version) {
+        throw new Error('version is required')
+    }
+    if (!env) {
+        throw new Error('env is required')
+    }
+    if (!gsLibPackagePath) {
+        throw new Error('gsLibPackagePath is required')
+    }
+    
+    // Dynamic imports to avoid bundling Node.js modules in browser builds
+    const path = await import('path')
+    const nodeFs = await import('fs/promises')
+    
+    const fs = await createNodeFileSystem(projectRoot)
+    const gsLibDistPath = path.join(gsLibPackagePath, 'dist')
+    const gsLibPublicPath = path.join(gsLibPackagePath, 'public')
+    const buildGsLibPath = '__build/gs-lib/index.js'
+    
+    // Calculate total steps early
+    const hasAssets = await fs.exists('assets')
+    const totalSteps = calculateTotalSteps(true, hasAssets, true, cleanAfterBuild ?? true)
+    
+    // Read map file
+    let step = 0
+    if (progress) progress(++step, "Reading map file...", totalSteps)
+    const mapContent = Buffer.from(await fs.readFile(mapFile)).toString('utf-8')
+    const gsMap: GsMap = JSON.parse(mapContent)
+    
+    const buildTitle = title || path.basename(mapFile, '.geospace')
+    
+    // Use standard copyAssets function
+    const copyAssets = createCopyAssetsFunction(fs)
+    
+    // Build using unified function
+    // Dynamic import to avoid bundling esbuild in browser builds
+    const esbuild = await import('esbuild')
+    
+    await buildMap(
+        {
+            title: buildTitle,
+            gsMap,
+            env,
+            version
+        },
+        fs,
+        await createNodeResolvePlugin(projectRoot, buildGsLibPath),
+        esbuild, // Pass Node.js esbuild instance
+        {
+            outputDir,
+            gsLibPackagePath,
+            cleanAfterBuild,
+            copyAssets,
+            startingStep: step,
+            totalSteps
+        } as any,
+        progress
+    )
+}
+

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@kispace-io/gs-lib",
+  "version": "0.0.0",
+  "type": "module",
+  "license": "EPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/erdalkaraca/geospace.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "map-builder": "./bin/map-builder.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "lib",
+    "public",
+    "bin",
+    "tsconfig.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ol": "^10.6.1",
+    "ol-mapbox-style": "^13.1.0"
+  },
+  "peerDependencies": {
+    "@kispace-io/appspace": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.2",
+    "@types/uuid": "^10.0.0",
+    "typescript": "~5.9.3",
+    "vite": "^7.1.12",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}

package/public/index.html

@@ -0,0 +1,69 @@
+<!doctype html>
+<html lang="en" translate="no">
+<head>
+    <meta charset="UTF-8"/>
+    <meta name="viewport" content="viewport-fit=cover, width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <meta name="google" content="notranslate">
+    
+    <meta name="mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-title" content="geospace-app" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+    
+    <link rel="icon" href="/assets/icons/icon_24.png" type="image/png" />
+    <link rel="manifest" href="manifest.json" />
+    
+    <title>$TITLE</title>
+    <link rel="stylesheet" href="app.css" />
+    <style>
+        html, body, .map-container {
+            height: 100dvh;
+            width: 100dvw;
+            margin: 0;
+            padding: 0;
+            overflow: hidden;
+        }
+        
+        .no-touch {
+            touch-action: none;
+        }
+    </style>
+</head>
+<body>
+<div class="map-container"></div>
+<script type="module">
+    import {renderMap} from "./app.js"
+    renderMap("div.map-container")
+</script>
+<script>
+    if ('serviceWorker' in navigator) {
+      window.onload = () => {
+        navigator.serviceWorker.register('/sw.js').then(registration => {
+          // Check for updates
+          registration.addEventListener('updatefound', () => {
+            const newWorker = registration.installing;
+            if (newWorker) {
+              newWorker.addEventListener('statechange', () => {
+                if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
+                  // New version available
+                  if (confirm('A new version of the app is available. Reload to update?')) {
+                    newWorker.postMessage({ type: 'SKIP_WAITING' });
+                    window.location.reload();
+                  }
+                }
+              });
+            }
+          });
+          
+          // Listen for service worker messages
+          navigator.serviceWorker.addEventListener('message', event => {
+            if (event.data && event.data.type === 'RELOAD') {
+              window.location.reload();
+            }
+          });
+        });
+      }
+    }
+  </script>
+</body>
+</html>
+

package/public/pwa/manifest.json

@@ -0,0 +1,54 @@
+{
+  "id": "/",
+  "scope": "/",
+  "name": "$PWA_NAME",
+  "display": "standalone",
+  "start_url": "/",
+  "short_name": "$PWA_SHORT_NAME",
+  "description": "$PWA_DESCRIPTION",
+  "version": "$PWA_VERSION",
+  "orientation": "any",
+  "related_applications": [],
+  "prefer_related_applications": false,
+  "display_override": [
+    "window-controls-overlay"
+  ],
+  "launch_handler": {
+    "client_mode": "focus-existing"
+  },
+  "icons": [
+    {
+      "src": "assets/icons/512x512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    },
+    {
+      "src": "assets/icons/192x192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "assets/icons/48x48.png",
+      "sizes": "48x48",
+      "type": "image/png"
+    },
+    {
+      "src": "assets/icons/24x24.png",
+      "sizes": "24x24",
+      "type": "image/png"
+    }
+  ],
+  "screenshots": [],
+  "features": [
+    "Cross Platform",
+    "fast",
+    "interactive"
+  ],
+  "categories": [
+    "mapping",
+    "geospatial",
+    "interaction"
+  ],
+  "shortcuts": [],
+  "widgets": []
+}

package/public/pwa/staticwebapp.config.json

@@ -0,0 +1,6 @@
+{
+  "navigationFallback": {
+    "rewrite": "index.html",
+    "exclude": ["*.{css,js,mjs,ts,png,gif,ico,jpg,svg,json,woff2,ttf}"]
+  }
+}