npm - @certe/atmos-editor - Versions diffs - 0.1.0 → 0.3.0 - Mend

@certe/atmos-editor 0.1.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@certe/atmos-editor",
   "description": "Browser-based Unity-style editor for the Atmos Engine — hierarchy, inspector, gizmos",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/certesolutions-cyber/atmos.git",
@@ -9,49 +9,57 @@
   },
   "homepage": "https://github.com/certesolutions-cyber/atmos",
   "license": "GPL-3.0-or-later",
-  "keywords": ["editor", "game-engine", "webgpu", "scene-editor", "gizmo", "inspector", "atmos"],
+  "keywords": [
+    "editor",
+    "game-engine",
+    "webgpu",
+    "scene-editor",
+    "gizmo",
+    "inspector",
+    "atmos"
+  ],
   "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./player": "./src/player-entry.ts",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./player": {
+      "types": "./dist/player-entry.d.ts",
+      "import": "./dist/player-entry.js"
+    },
     "./vite": {
       "types": "./vite-plugin.d.ts",
-      "import": "./vite-plugin.mjs"
+      "import": "./vite-plugin.mjs",
+      "require": "./vite-plugin.cjs"
     }
   },
-  "publishConfig": {
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js"
-      },
-      "./player": {
-        "types": "./dist/player-entry.d.ts",
-        "import": "./dist/player-entry.js"
-      },
-      "./vite": {
-        "types": "./vite-plugin.d.ts",
-        "import": "./vite-plugin.mjs"
-      }
-    }
-  },
-  "files": ["dist", "!dist/__tests__", "vite-plugin.mjs", "vite-plugin.d.ts", "package.json", "README.md", "LICENCE"],
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "vite-plugin.mjs",
+    "vite-plugin.cjs",
+    "vite-plugin.d.ts",
+    "package.json",
+    "README.md",
+    "LICENCE"
+  ],
   "peerDependencies": {
     "vite": ">=5.0.0"
   },
   "peerDependenciesMeta": {
-    "vite": { "optional": true }
+    "vite": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "@certe/atmos-animation": "^0.1.0",
-    "@certe/atmos-assets": "^0.1.0",
-    "@certe/atmos-core": "^0.1.0",
-    "@certe/atmos-math": "^0.1.0",
-    "@certe/atmos-renderer": "^0.1.0",
+    "@certe/atmos-animation": "^0.3.0",
+    "@certe/atmos-assets": "^0.3.0",
+    "@certe/atmos-core": "^0.3.0",
+    "@certe/atmos-math": "^0.3.0",
+    "@certe/atmos-renderer": "^0.3.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },

package/vite-plugin.cjs ADDED Viewed

@@ -0,0 +1,397 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const DEFAULT_EXCLUDE = new Set([
+  'node_modules', '.git', 'dist', '.vite', '.turbo', '__pycache__',
+]);
+function scanDirectory(dirPath, relativeTo, exclude) {
+  const entries = [];
+  let items;
+  try {
+    items = fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return entries;
+  }
+  for (const item of items) {
+    if (exclude.has(item.name) || item.name.startsWith('.')) continue;
+    const fullPath = path.join(dirPath, item.name);
+    const relPath = path.relative(relativeTo, fullPath).replace(/\\/g, '/');
+    if (item.isDirectory()) {
+      entries.push({
+        path: relPath,
+        name: item.name,
+        kind: 'directory',
+        extension: '',
+        children: scanDirectory(fullPath, relativeTo, exclude),
+      });
+    } else {
+      const ext = path.extname(item.name).slice(1);
+      entries.push({
+        path: relPath,
+        name: item.name,
+        kind: 'file',
+        extension: ext,
+      });
+    }
+  }
+  return entries.sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === 'directory' ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function generateEditorHtml(entry) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Atmos Editor</title>
+</head>
+<body>
+  <script type="module" src="/${entry}"></script>
+</body>
+</html>`;
+}
+function generatePlayerHtml(entry) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Atmos Game</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { width: 100%; height: 100%; overflow: hidden; background: #000; }
+    #atmos-container { position: relative; width: 100%; height: 100%; }
+    #atmos-canvas { width: 100%; height: 100%; display: block; }
+    #atmos-ui { position: absolute; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; }
+    #atmos-ui * { pointer-events: auto; }
+  </style>
+</head>
+<body>
+  <div id="atmos-container">
+    <canvas id="atmos-canvas"></canvas>
+    <div id="atmos-ui"></div>
+  </div>
+  <script type="module" src="/${entry}"></script>
+</body>
+</html>`;
+}
+const VIRTUAL_BUILD_ENTRY = 'virtual:atmos-build-entry';
+const RESOLVED_BUILD_ENTRY = '\0virtual:atmos-build-entry';
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const item of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, item.name);
+    const destPath = path.join(dest, item.name);
+    if (item.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+/** Collect body data from an IncomingMessage. */
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', (c) => chunks.push(c));
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+/** @param {import('./vite-plugin.d.ts').AtmosPluginOptions} [options] */
+function atmosPlugin(options) {
+  const include = options?.include ?? ['src'];
+  const exclude = new Set([...DEFAULT_EXCLUDE, ...(options?.exclude ?? [])]);
+  const entry = options?.entry ?? 'src/main.ts';
+  let root = '';
+  let generatedIndex = '';
+  let isBuild = false;
+  return {
+    name: 'atmos-editor',
+    config(cfg, { command }) {
+      root = cfg.root || process.cwd();
+      isBuild = command === 'build';
+      if (isBuild) {
+        // In build mode, generate player HTML (not editor)
+        const indexPath = path.resolve(root, 'index.html');
+        const userHasIndex = fs.existsSync(indexPath);
+        if (!userHasIndex) {
+          fs.writeFileSync(indexPath, generatePlayerHtml(VIRTUAL_BUILD_ENTRY));
+          generatedIndex = indexPath;
+        }
+        return {
+          build: {
+            target: cfg.build?.target ?? 'esnext',
+            rollupOptions: {
+              ...cfg.build?.rollupOptions,
+            },
+          },
+        };
+      }
+      // Dev mode — generate editor HTML if no index.html exists
+      const indexPath = path.resolve(root, 'index.html');
+      if (!fs.existsSync(indexPath)) {
+        fs.writeFileSync(indexPath, generateEditorHtml(entry));
+        generatedIndex = indexPath;
+      }
+      return {
+        build: {
+          target: cfg.build?.target ?? 'esnext',
+        },
+      };
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_BUILD_ENTRY || id === '/' + VIRTUAL_BUILD_ENTRY) {
+        return RESOLVED_BUILD_ENTRY;
+      }
+    },
+    load(id) {
+      if (id !== RESOLVED_BUILD_ENTRY) return;
+      let sceneName = 'main';
+      try {
+        const settingsPath = path.join(root, 'project-settings.json');
+        if (fs.existsSync(settingsPath)) {
+          const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+          if (settings.defaultScene) sceneName = settings.defaultScene;
+        }
+      } catch { /* use default */ }
+      return `
+import { startPlayer, createEditorPhysics } from '@certe/atmos-editor/player';
+const scriptModules = import.meta.glob('/src/scripts/*.ts', { eager: true });
+try {
+  const physics = await createEditorPhysics();
+  const app = await startPlayer({
+    scene: 'scenes/${sceneName}.scene.json',
+    physics,
+    scriptModules,
+  });
+} catch (err) {
+  document.body.style.background = '#111';
+  document.body.style.color = '#f88';
+  document.body.style.padding = '2em';
+  document.body.style.fontFamily = 'monospace';
+  document.body.textContent = 'Atmos: ' + (err instanceof Error ? err.message : String(err));
+}
+`;
+    },
+    transformIndexHtml: {
+      order: 'pre',
+      handler(html) {
+        if (!isBuild) return html;
+        // Replace any existing script src with the virtual build entry
+        const hasScript = /<script\s+type="module"\s+src="[^"]*"[^>]*><\/script>/.test(html);
+        if (hasScript) {
+          return html.replace(
+            /<script\s+type="module"\s+src="[^"]*"([^>]*)><\/script>/,
+            `<script type="module" src="/${VIRTUAL_BUILD_ENTRY}"$1></script>`,
+          );
+        }
+        // No script tag — inject one before </body>
+        return html.replace('</body>', `  <script type="module" src="/${VIRTUAL_BUILD_ENTRY}"></script>\n</body>`);
+      },
+    },
+    closeBundle() {
+      if (generatedIndex) {
+        try { fs.unlinkSync(generatedIndex); } catch { /* ignore */ }
+        generatedIndex = '';
+      }
+    },
+    writeBundle(options) {
+      if (!isBuild) return;
+      const outDir = options.dir || path.resolve(root, 'dist');
+      const assetDirs = ['scenes', 'materials', 'textures', 'models'];
+      for (const dir of assetDirs) {
+        const src = path.resolve(root, dir);
+        if (fs.existsSync(src)) {
+          copyDirSync(src, path.join(outDir, dir));
+        }
+      }
+    },
+    configureServer(server) {
+      root = server.config.root;
+      // Auto-generate index.html when none exists
+      const indexPath = path.resolve(root, 'index.html');
+      if (!fs.existsSync(indexPath)) {
+        server.middlewares.use((req, res, next) => {
+          if (req.url === '/' || req.url === '/index.html') {
+            const rawHtml = generateEditorHtml(entry);
+            server.transformIndexHtml(req.url, rawHtml).then((html) => {
+              res.statusCode = 200;
+              res.setHeader('Content-Type', 'text/html');
+              res.end(html);
+            });
+            return;
+          }
+          next();
+        });
+      }
+      // Serve asset tree as JSON
+      server.middlewares.use('/__atmos_assets', (_req, res) => {
+        const allEntries = [];
+        for (const dir of include) {
+          const absDir = path.resolve(root, dir);
+          if (fs.existsSync(absDir)) {
+            allEntries.push(...scanDirectory(absDir, root, exclude));
+          }
+        }
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify({ root, entries: allEntries }));
+      });
+      // ── Project filesystem endpoints ──────────────────
+      server.middlewares.use((req, res, next) => {
+        if (!req.url || !req.url.startsWith('/__atmos_fs/')) { next(); return; }
+        const url = new URL(req.url, 'http://localhost');
+        const action = url.pathname.slice('/__atmos_fs'.length); // e.g. /read, /info
+        const filePath = url.searchParams.get('path') ?? '';
+        // /info and /tree don't need a file path
+        if (action === '/info') {
+          res.setHeader('Content-Type', 'application/json');
+          res.end(JSON.stringify({ name: path.basename(root), root }));
+          return;
+        }
+        if (action === '/tree') {
+          const allEntries = scanDirectory(root, root, exclude);
+          res.setHeader('Content-Type', 'application/json');
+          res.end(JSON.stringify(allEntries));
+          return;
+        }
+        // Prevent path traversal for file operations
+        const absPath = path.resolve(root, filePath);
+        if (!absPath.startsWith(root)) {
+          res.statusCode = 403;
+          res.end('Forbidden');
+          return;
+        }
+        // Handle async actions (write needs body collection)
+        handleFsAction(action, absPath, filePath, root, exclude, req, res, server).catch((err) => {
+          res.statusCode = 500;
+          res.end(String(err));
+        });
+      });
+      // Watch for file changes and push HMR custom events
+      server.watcher.on('all', (event, filePath) => {
+        if (event !== 'add' && event !== 'change' && event !== 'unlink') return;
+        const relPath = path.relative(root, filePath).replace(/\\/g, '/');
+        const inScope = include.some((dir) => relPath.startsWith(dir));
+        if (inScope) {
+          server.hot.send('atmos:asset-change', { kind: event, path: relPath });
+        }
+        // Also notify for project files (materials, scenes, etc.)
+        if (relPath.startsWith('materials/') || relPath.startsWith('scenes/') || relPath.startsWith('textures/')) {
+          server.hot.send('atmos:project-change', { kind, path: relPath });
+        }
+      });
+    },
+  };
+}
+async function handleFsAction(action, absPath, filePath, root, exclude, req, res, server) {
+  switch (action) {
+    case '/read': {
+      const data = fs.readFileSync(absPath);
+      res.setHeader('Content-Type', 'application/octet-stream');
+      res.end(data);
+      break;
+    }
+    case '/read-text': {
+      const text = fs.readFileSync(absPath, 'utf-8');
+      res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+      res.end(text);
+      break;
+    }
+    case '/write': {
+      const body = await collectBody(req);
+      const dir = path.dirname(absPath);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(absPath, body);
+      res.end('ok');
+      notifyFileChange(server, root, filePath, 'change');
+      break;
+    }
+    case '/delete': {
+      fs.unlinkSync(absPath);
+      res.end('ok');
+      notifyFileChange(server, root, filePath, 'unlink');
+      break;
+    }
+    case '/exists': {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify(fs.existsSync(absPath)));
+      break;
+    }
+    case '/mkdir': {
+      fs.mkdirSync(absPath, { recursive: true });
+      res.end('ok');
+      break;
+    }
+    case '/list': {
+      const dir = filePath || '.';
+      const absDir = path.resolve(root, dir);
+      const files = listRecursive(absDir, filePath ? `${filePath}/` : '');
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify(files));
+      break;
+    }
+    default:
+      res.statusCode = 404;
+      res.end('Unknown action');
+  }
+}
+function notifyFileChange(server, root, filePath, kind) {
+  // Send HMR event immediately (don't wait for chokidar watcher)
+  server.hot.send('atmos:project-change', { kind, path: filePath });
+}
+function listRecursive(dirPath, prefix) {
+  const results = [];
+  let items;
+  try {
+    items = fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const item of items) {
+    if (item.name.startsWith('.')) continue;
+    const full = path.join(dirPath, item.name);
+    if (item.isFile()) {
+      results.push(prefix + item.name);
+    } else if (item.isDirectory()) {
+      results.push(...listRecursive(full, `${prefix}${item.name}/`));
+    }
+  }
+  return results.sort();
+}
+/** @deprecated Use atmosPlugin() instead */
+const atmosAssetsPlugin = atmosPlugin;
+module.exports = { atmosPlugin, atmosAssetsPlugin };

package/src/index.ts DELETED Viewed

@@ -1,48 +0,0 @@
-export { EditorState } from './editor-state.js';
-export type { EditorEvent } from './editor-state.js';
-export { mountEditor } from './editor-mount.js';
-export type { MountEditorOptions, MountEditorResult, PrimitiveType } from './editor-mount.js';
-export { getProperty, setProperty } from './property-setters.js';
-export { OrbitCamera } from './orbit-camera.js';
-export { ObjectPicker } from './object-picker.js';
-export type { PickResult } from './object-picker.js';
-export { computeSelectionCenter } from './selection-utils.js';
-export { GizmoState } from './gizmo-state.js';
-export type { GizmoMode, GizmoAxis } from './gizmo-state.js';
-export { GizmoRenderer } from './gizmo-renderer.js';
-export { OverlayRenderer } from './overlay-renderer.js';
-export { CAMERA_PRESETS, applyCameraPreset } from './camera-presets.js';
-export type { CameraPreset } from './camera-presets.js';
-export {
-  findObjectById,
-  duplicateGameObject,
-  deleteGameObject,
-  canReparent,
-  reparentGameObject,
-  setReparentValidator,
-  setOnReparent,
-  setOnDuplicate,
-} from './scene-operations.js';
-export type { ReparentValidator, ReparentCallback, DuplicateCallback } from './scene-operations.js';
-export { takeSnapshot, restoreSnapshot } from './scene-snapshot.js';
-export type { SceneSnapshot } from './scene-snapshot.js';
-export { AssetBrowserClient } from './asset-browser-client.js';
-export type { AssetEntry, AssetListResponse, AssetChangeEvent, ScriptAsset } from './asset-types.js';
-export { discoverScripts, autoDiscoverScripts } from './script-discovery.js';
-export { ProjectFileSystem } from './project-fs.js';
-export { MaterialManager } from './material-manager.js';
-export { ProjectSettingsManager } from './project-settings.js';
-export type { PhysicsSettings, ProjectSettings } from './project-settings.js';
-export { startEditor } from './bootstrap/start-editor.js';
-export { startPlayer } from './bootstrap/start-player.js';
-export type { PlayerConfig, PlayerApp } from './bootstrap/start-player.js';
-export { createEditorPhysics } from './bootstrap/editor-physics.js';
-export { SimpleMaterialLoader } from './simple-material-loader.js';
-export type {
-  EditorConfig,
-  EditorApp,
-  EditorPhysicsPlugin,
-  SceneSetupContext,
-  MeshLike,
-  PhysicsInitContext,
-} from './bootstrap/types.js';