@weave-apps/sdk 0.5.0 → 0.7.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

@@ -3,7 +3,10 @@
 /**
  * Weave App Compiler
  *
- * Compiles TypeScript and transpiles to Weave-ready JavaScript
+ * Compiles TypeScript and transpiles to Weave-ready JavaScript.
+ * Supports multi-file apps by bundling all imports into a single output file.
+ *
+ * Uses esbuild for bundling and tsc for type-checking only.
  */
 
 const { execSync } = require('child_process');
@@ -74,42 +77,82 @@ if (!fs.existsSync(tsconfigPath)) {
   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)) {
     fs.mkdirSync(distDir, { recursive: true });
   }
 
-  // Step 1: Compile TypeScript using SDK's tsconfig and TypeScript
-  console.log('📦 Compiling TypeScript...');
+  const entryPoint = path.join(appDir, 'src', 'app.ts');
+  const targetFile = path.join(distDir, `${appName}.js`);
+
+  // Step 1: Type-check with tsc (no emit)
+  console.log('🔍 Type-checking with TypeScript...');
   const tscCommand = tscPath === 'npx tsc'
-    ? `npx tsc --project ${tsconfigPath} --outDir ${distDir} --rootDir ${appDir}/src`
-    : `"${tscPath}" --project ${tsconfigPath} --outDir ${distDir} --rootDir ${appDir}/src`;
+    ? `npx tsc --project ${tsconfigPath} --noEmit`
+    : `"${tscPath}" --project ${tsconfigPath} --noEmit`;
 
   execSync(tscCommand, {
     stdio: 'inherit',
     cwd: appDir
   });
 
-  // Rename app.js to {appName}.js
-  const compiledFile = path.join(distDir, 'app.js');
-  const targetFile = path.join(distDir, `${appName}.js`);
+  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 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 (fs.existsSync(compiledFile)) {
-    fs.renameSync(compiledFile, targetFile);
+  if (result.errors.length > 0) {
+    console.error('❌ esbuild errors:', result.errors);
+    process.exit(1);
   }
 
-  console.log('✅ TypeScript compiled\n');
+  console.log('✅ Bundle complete\n');
 
-  // Step 2: Extract settings schema and inject into compiled JS
+  // Step 3: Extract settings schema and inject into compiled JS
   console.log('📋 Extracting settings schema...');
   const extractSchemaScript = path.join(sdkDir, 'scripts', 'extract-settings-schema.js');
-  const sourceFile = path.join(appDir, 'src', 'app.ts');
 
-  if (fs.existsSync(extractSchemaScript) && fs.existsSync(sourceFile)) {
+  if (fs.existsSync(extractSchemaScript) && fs.existsSync(entryPoint)) {
     try {
-      execSync(`node "${extractSchemaScript}" "${sourceFile}" "${targetFile}"`, {
+      execSync(`node "${extractSchemaScript}" "${entryPoint}" "${targetFile}"`, {
         stdio: 'inherit',
         cwd: appDir
       });
@@ -120,15 +163,16 @@ try {
 
   console.log('');
 
-  // Step 3: Run weave-build to transpile
+  // 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,88 @@
+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 });
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-apps/sdk",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "SDK for building Weave Micro Apps",
   "publishConfig": {
     "access": "public"
@@ -32,6 +32,7 @@
   "author": "Weave Platform",
   "license": "MIT",
   "dependencies": {
+    "esbuild": "^0.24.0",
     "typescript": "^5.9.3"
   },
   "devDependencies": {

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}`);