@weave-apps/sdk 0.6.0 → 0.8.0

package/bin/build.js

@@ -3,7 +3,13 @@
 /**
  * Weave App Builder
  * 
- * Transpiles TypeScript to clean JavaScript for Weave Platform
+ * Post-processes the esbuild IIFE bundle for the Weave Platform.
+ * Adds a header comment and removes the "use strict" directive.
+ *
+ * The esbuild IIFE format wraps all code in (() => { ... })() so
+ * helper functions and variables stay private to the closure.
+ * SDK globals (WeaveBaseApp, weaveDOM, weaveAPI) are resolved
+ * inside the closure by the esbuild plugin in compile.js.
  */
 
 const fs = require('fs');
@@ -29,31 +35,17 @@ const distFile = path.join(appDir, 'dist', `${appName}.js`);
 // Check if dist file exists
 if (!fs.existsSync(distFile)) {
   console.error(`❌ Error: dist/${appName}.js not found`);
-  console.error('Run "tsc" first to compile TypeScript');
+  console.error('Run "weave-compile" first to compile TypeScript');
   process.exit(1);
 }
 
 console.log('🔨 Building Weave app...\n');
 
-// Read compiled TypeScript output
+// Read esbuild IIFE output
 let code = fs.readFileSync(distFile, 'utf8');
 
-// Remove import statements (SDK is globally available)
-code = code.replace(/^import .* from .*$/gm, '');
-code = code.replace(/^import .*$/gm, '');
-
-// Remove export statements
-code = code.replace(/^export \{[^}]*\};?$/gm, '');
-code = code.replace(/^export /gm, '');
-
-// Replace WeaveBaseApp with window.WeaveBaseApp
-code = code.replace(/extends WeaveBaseApp/g, 'extends window.WeaveBaseApp');
-
-// Replace weaveDOM with window.weaveDOM (but not if already prefixed with window. or this.)
-code = code.replace(/(?<!window\.)(?<!this\.)weaveDOM\./g, 'window.weaveDOM.');
-
-// Replace weaveAPI with window.weaveAPI (but not if already prefixed with window. or this.)
-code = code.replace(/(?<!window\.)(?<!this\.)weaveAPI\./g, 'window.weaveAPI.');
+// Remove "use strict" directive (esbuild adds it, not needed in IIFE)
+code = code.replace(/^"use strict";\n/gm, '');
 
 // Remove empty lines created by removals
 code = code.replace(/\n\n\n+/g, '\n\n');
@@ -65,10 +57,6 @@ const header = `/**
  * Built with Weave App SDK
  * Generated: ${new Date().toISOString()}
  */
-
-// Access SDK from window globals
-const { WeaveBaseApp, weaveDOM } = window;
-
 `;
 
 code = header + code;

package/bin/compile.js

@@ -77,28 +77,7 @@ if (!fs.existsSync(tsconfigPath)) {
   process.exit(1);
 }
 
-// Look for esbuild in multiple locations
-let esbuildPath = null;
-const possibleEsbuildPaths = [
-  path.join(appDir, 'node_modules', '.bin', 'esbuild'),
-  path.join(sdkDir, 'node_modules', '.bin', 'esbuild'),
-];
-
-for (const candidate of possibleEsbuildPaths) {
-  if (fs.existsSync(candidate)) {
-    esbuildPath = candidate;
-    break;
-  }
-}
-
-if (!esbuildPath) {
-  console.error('❌ Error: esbuild not found');
-  console.error('It should be installed as part of @weave-apps/sdk.');
-  console.error('Try running: npm install');
-  process.exit(1);
-}
-
-try {
+async function compile() {
   // Create dist directory if it doesn't exist
   const distDir = path.join(appDir, 'dist');
   if (!fs.existsSync(distDir)) {
@@ -109,7 +88,7 @@ try {
   const targetFile = path.join(distDir, `${appName}.js`);
 
   // Step 1: Type-check with tsc (no emit)
-  console.log('� Type-checking with TypeScript...');
+  console.log('🔍 Type-checking with TypeScript...');
   const tscCommand = tscPath === 'npx tsc'
     ? `npx tsc --project ${tsconfigPath} --noEmit`
     : `"${tscPath}" --project ${tsconfigPath} --noEmit`;
@@ -122,25 +101,49 @@ try {
   console.log('✅ Type-check passed\n');
 
   // Step 2: Bundle with esbuild (all imports resolved into single file)
+  // Uses IIFE format so all code is wrapped in a closure — no global namespace pollution.
+  // Helper functions, utilities, etc. stay private inside the closure.
+  // Only customElements.define() escapes to register the web component.
   console.log('📦 Bundling with esbuild...');
-  const esbuildCommand = [
-    `"${esbuildPath}"`,
-    `"${entryPoint}"`,
-    '--bundle',
-    `--outfile="${targetFile}"`,
-    '--format=esm',
-    '--target=es2020',
-    '--platform=browser',
-    // Mark SDK as external — build.js will replace with window globals
-    '--external:@weave-apps/sdk',
-    '--external:@weave/app-sdk',
-  ].join(' ');
-
-  execSync(esbuildCommand, {
-    stdio: 'inherit',
-    cwd: appDir
+  const esbuild = require('esbuild');
+
+  // Plugin to resolve SDK imports to window globals instead of trying to find the package
+  const weaveSDKPlugin = {
+    name: 'weave-sdk-globals',
+    setup(build) {
+      // Intercept imports of the SDK packages
+      build.onResolve({ filter: /^@weave-apps\/sdk$|^@weave\/app-sdk$/ }, (args) => {
+        return { path: args.path, namespace: 'weave-sdk' };
+      });
+      // Return a virtual module that re-exports from window globals
+      build.onLoad({ filter: /.*/, namespace: 'weave-sdk' }, () => {
+        return {
+          contents: `
+            export const WeaveBaseApp = window.WeaveBaseApp;
+            export const weaveDOM = window.weaveDOM;
+            export const weaveAPI = window.weaveAPI;
+          `,
+          loader: 'js',
+        };
+      });
+    },
+  };
+
+  const result = await esbuild.build({
+    entryPoints: [entryPoint],
+    bundle: true,
+    outfile: targetFile,
+    format: 'iife',
+    target: 'es2020',
+    platform: 'browser',
+    plugins: [weaveSDKPlugin],
   });
 
+  if (result.errors.length > 0) {
+    console.error('❌ esbuild errors:', result.errors);
+    process.exit(1);
+  }
+
   console.log('✅ Bundle complete\n');
 
   // Step 3: Extract settings schema and inject into compiled JS
@@ -160,15 +163,16 @@ try {
 
   console.log('');
 
-  // Step 4: Run weave-build to transpile (strip imports, add window globals)
+  // Step 4: Run weave-build to add header comment
   console.log('🔧 Transpiling to Weave format...');
   const buildScript = path.join(__dirname, 'build.js');
   execSync(`node "${buildScript}"`, {
     stdio: 'inherit',
     cwd: appDir
   });
+}
 
-} catch (error) {
+compile().catch((error) => {
   console.error('\n❌ Build failed');
   process.exit(1);
-}
+});

package/bin/extract-settings-schema.test.js

@@ -0,0 +1,104 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const scriptPath = path.resolve(__dirname, '../scripts/extract-settings-schema.js');
+
+function createTempFiles(jsContent) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'weave-extract-settings-'));
+  const tsPath = path.join(tmpDir, 'app.ts');
+  const jsPath = path.join(tmpDir, 'bundle.js');
+
+  const tsContent = `
+import { WeaveBaseApp } from '@weave-apps/sdk';
+
+interface AppSettings {
+  /** @description Example domain */
+  /** @default "https://example.com" */
+  DCP_DOMAIN?: string;
+}
+
+class DemoApp extends WeaveBaseApp<AppSettings, Record<string, never>> {
+  constructor() {
+    super({ id: 'demo', name: 'Demo', version: '1.0.0' });
+  }
+}
+`;
+
+  fs.writeFileSync(tsPath, tsContent, 'utf8');
+  fs.writeFileSync(jsPath, jsContent, 'utf8');
+
+  return { tmpDir, tsPath, jsPath };
+}
+
+function runScript(tsPath, jsPath) {
+  execFileSync('node', [scriptPath, tsPath, jsPath], { stdio: 'pipe' });
+}
+
+describe('extract-settings-schema script', () => {
+  it('injects schema for class declarations extending window.WeaveBaseApp', () => {
+    const { tmpDir, tsPath, jsPath } = createTempFiles(
+      `class DemoApp extends window.WeaveBaseApp { constructor() {} }`
+    );
+
+    try {
+      runScript(tsPath, jsPath);
+      const output = fs.readFileSync(jsPath, 'utf8');
+      assert.match(output, /@weave-settings-schema/);
+      assert.match(output, /class DemoApp extends window\.WeaveBaseApp/);
+      assert.match(output, /"key": "DCP_DOMAIN"/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('injects schema for assigned anonymous classes in bundled output', () => {
+    const { tmpDir, tsPath, jsPath } = createTempFiles(
+      `var DemoApp = class extends window.WeaveBaseApp { constructor() {} };`
+    );
+
+    try {
+      runScript(tsPath, jsPath);
+      const output = fs.readFileSync(jsPath, 'utf8');
+      assert.match(output, /@weave-settings-schema/);
+      assert.match(output, /var DemoApp = class extends window\.WeaveBaseApp/);
+      assert.match(output, /"defaultValue": "https:\/\/example.com"/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('does not inject twice when schema already exists', () => {
+    const { tmpDir, tsPath, jsPath } = createTempFiles(
+      `/**\n * @weave-settings-schema []\n */\nvar DemoApp = class extends window.WeaveBaseApp { constructor() {} };`
+    );
+
+    try {
+      runScript(tsPath, jsPath);
+      const output = fs.readFileSync(jsPath, 'utf8');
+      const schemaOccurrences = (output.match(/@weave-settings-schema/g) || []).length;
+      assert.equal(schemaOccurrences, 1);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('injects schema when compiling the real heidi-to-dcp mock app with local SDK scripts', () => {
+    const mockAppDir = path.resolve(__dirname, '../mocks/heidi-to-dcp');
+    const compileScriptPath = path.resolve(__dirname, 'compile.js');
+    const outputPath = path.join(mockAppDir, 'dist', 'demo-weave-heidi-dcp.js');
+
+    execFileSync('node', [compileScriptPath], {
+      cwd: mockAppDir,
+      stdio: 'pipe',
+    });
+
+    const output = fs.readFileSync(outputPath, 'utf8');
+    assert.match(output, /@weave-settings-schema/);
+    assert.match(output, /"key": "DCP_DOMAIN"/);
+    assert.match(output, /"key": "HEIDI_CLIENT_NAME_SELECTOR"/);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-apps/sdk",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "SDK for building Weave Micro Apps",
   "publishConfig": {
     "access": "public"

package/scripts/extract-settings-schema.js

@@ -173,14 +173,34 @@ function injectSchemaIntoJS(jsFilePath, schema) {
 
   let jsCode = fs.readFileSync(jsFilePath, 'utf-8');
 
-  // Find the class definition
-  const classMatch = jsCode.match(/class\s+(\w+)\s+extends\s+WeaveBaseApp/);
-  if (!classMatch) {
-    console.warn('⚠️  Could not find class extending WeaveBaseApp');
+  if (jsCode.includes('@weave-settings-schema')) {
+    console.log('ℹ️  Settings schema already present, skipping injection');
     return;
   }
 
-  const className = classMatch[1];
+  // Find app class definitions in both source-like and bundled outputs.
+  // Examples:
+  //   class MyApp extends WeaveBaseApp
+  //   class MyApp extends window.WeaveBaseApp
+  //   var MyApp = class extends window.WeaveBaseApp
+  const classDefinitionPatterns = [
+    /(?:var|let|const)\s+\w+\s*=\s*class(?:\s+\w+)?\s+extends\s+(?:window\.)?WeaveBaseApp\b/,
+    /class\s+\w+\s+extends\s+(?:window\.)?WeaveBaseApp\b/,
+  ];
+
+  let classDefinition = null;
+  for (const pattern of classDefinitionPatterns) {
+    const match = jsCode.match(pattern);
+    if (match) {
+      classDefinition = match[0];
+      break;
+    }
+  }
+
+  if (!classDefinition) {
+    console.warn('⚠️  Could not find class extending WeaveBaseApp');
+    return;
+  }
 
   // Create JSDoc comment with schema
   const schemaComment = `
@@ -189,10 +209,8 @@ function injectSchemaIntoJS(jsFilePath, schema) {
  */`;
 
   // Inject before class definition
-  jsCode = jsCode.replace(
-    new RegExp(`(class\\s+${className}\\s+extends\\s+WeaveBaseApp)`, 'g'),
-    `${schemaComment}\n$1`
-  );
+  const classDefinitionIndex = jsCode.indexOf(classDefinition);
+  jsCode = `${jsCode.slice(0, classDefinitionIndex)}${schemaComment}\n${jsCode.slice(classDefinitionIndex)}`;
 
   fs.writeFileSync(jsFilePath, jsCode, 'utf-8');
   console.log(`✅ Injected settings schema into ${jsFilePath}`);