metaowl 0.4.0 → 0.5.0

package/build/runtime/vite/plugin.js

@@ -0,0 +1,183 @@
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { config as dotenvConfig } from 'dotenv';
+import { globSync } from 'glob';
+import tsconfigPaths from 'vite-tsconfig-paths';
+const require = createRequire(import.meta.url);
+function resolveOwlPath() {
+    return require.resolve('@odoo/owl/dist/owl.es.js', {
+        paths: [process.cwd(), dirname(fileURLToPath(import.meta.url))]
+    });
+}
+function collectXml(globPattern) {
+    return globSync(globPattern).map((filePath) => filePath.replace(/^src[\\/]/, '/'));
+}
+function mergeXmlFiles(xmlPaths) {
+    const templates = xmlPaths.map((filePath) => {
+        try {
+            let content = readFileSync(filePath, 'utf-8');
+            content = content.replace(/<templates>/g, '').replace(/<\/templates>/g, '');
+            return content;
+        }
+        catch (error) {
+            console.error(`[metaowl] Failed to read XML file: ${filePath}`, error);
+            return '';
+        }
+    }).join('');
+    return '<templates>' + templates + '</templates>';
+}
+export async function metaowlPlugin(options = {}) {
+    const { root = 'src', outDir = '../dist', publicDir = '../public', componentsDir = 'src/components', pagesDir = 'src/pages', layoutsDir = 'src/layouts', frameworkEntry = './node_modules/metaowl/index.js', vendorPackages = ['@odoo/owl'], autoImport = {}, envPrefix } = options;
+    const componentXml = collectXml(`${componentsDir}/**/*.xml`);
+    const pageXml = collectXml(`${pagesDir}/**/*.xml`);
+    const layoutXml = collectXml(`${layoutsDir}/**/*.xml`);
+    const allComponents = [...layoutXml, ...pageXml, ...componentXml];
+    let outDirResolved = null;
+    const autoImportDtsPath = resolve(process.cwd(), '.metaowl', 'components.d.ts');
+    let autoImportPlugin = null;
+    if (autoImport.enabled) {
+        const { generateComponentDts, scanComponents } = await import('../modules/auto-import.js');
+        const components = await scanComponents(componentsDir, { pattern: autoImport.pattern || '*.js' });
+        const metaowlDir = dirname(autoImportDtsPath);
+        if (!existsSync(metaowlDir)) {
+            mkdirSync(metaowlDir, { recursive: true });
+        }
+        await generateComponentDts(components, autoImportDtsPath);
+        autoImportPlugin = {
+            name: 'metaowl:auto-import',
+            enforce: 'pre',
+            configResolved() {
+                // Components are scanned at startup.
+            },
+            handleHotUpdate({ file }) {
+                if (file.startsWith(resolve(componentsDir)) && file.endsWith('.js')) {
+                    void scanComponents(componentsDir, { pattern: autoImport.pattern || '*.js' }).then((nextComponents) => {
+                        return generateComponentDts(nextComponents, autoImportDtsPath);
+                    });
+                }
+            }
+        };
+    }
+    const plugins = [
+        ...(autoImportPlugin ? [autoImportPlugin] : []),
+        tsconfigPaths({ root: process.cwd() }),
+        {
+            name: 'metaowl:define',
+            config(cfg, { mode }) {
+                dotenvConfig();
+                const isDev = mode === 'development';
+                const safeEnv = Object.fromEntries(Object.entries(process.env).filter(([key]) => key === 'NODE_ENV' || (envPrefix && key.startsWith(envPrefix))));
+                cfg.define = {
+                    ...(cfg.define ?? {}),
+                    DEV_MODE: isDev,
+                    COMPONENTS: JSON.stringify(isDev ? allComponents : ['/templates.xml']),
+                    'process.env': safeEnv
+                };
+                cfg.root = cfg.root ?? root;
+                cfg.publicDir = cfg.publicDir ?? publicDir;
+                cfg.appType = cfg.appType ?? 'spa';
+                const owlPath = resolveOwlPath();
+                cfg.resolve = {
+                    ...(cfg.resolve ?? {}),
+                    alias: {
+                        ...(cfg.resolve?.alias ?? {}),
+                        '@odoo/owl': owlPath
+                    }
+                };
+                cfg.build = {
+                    outDir,
+                    emptyOutDir: true,
+                    sourcemap: isDev,
+                    chunkSizeWarningLimit: 1024,
+                    target: 'esnext',
+                    rollupOptions: {
+                        input: resolve(root, 'index.html'),
+                        output: {
+                            manualChunks: {
+                                vendor: vendorPackages,
+                                framework: [frameworkEntry]
+                            }
+                        }
+                    },
+                    ...(cfg.build ?? {})
+                };
+                cfg.optimizeDeps = {
+                    include: ['@odoo/owl'],
+                    ...(cfg.optimizeDeps ?? {})
+                };
+            },
+            configResolved(resolvedConfig) {
+                outDirResolved = resolve(resolvedConfig.root, resolvedConfig.build.outDir);
+            }
+        },
+        {
+            name: 'metaowl:app',
+            transform(code, id) {
+                if (!id.endsWith('/metaowl.js'))
+                    return null;
+                const pagesRel = pagesDir.replace(new RegExp(`^${root}[\\/]`), '');
+                const layoutsRel = layoutsDir.replace(new RegExp(`^${root}[\\/]`), '');
+                return {
+                    code: code.replace(/boot\(\s*\)/, `boot(import.meta.glob('./${pagesRel}/**/*.js', { eager: true }), import.meta.glob('./${layoutsRel}/**/*.js', { eager: true }))`),
+                    map: null
+                };
+            }
+        },
+        {
+            name: 'metaowl:styles',
+            transform(code, id) {
+                if (!id.endsWith('/css.js'))
+                    return null;
+                const compRel = componentsDir.replace(new RegExp(`^${root}[\\/]`), '');
+                const pagesRel = pagesDir.replace(new RegExp(`^${root}[\\/]`), '');
+                const layoutsRel = layoutsDir.replace(new RegExp(`^${root}[\\/]`), '');
+                return {
+                    code: code + '\n' +
+                        `import.meta.glob('/${compRel}/**/*.{css,scss}', { eager: true })\n` +
+                        `import.meta.glob('/${pagesRel}/**/*.{css,scss}', { eager: true })\n` +
+                        `import.meta.glob('/${layoutsRel}/**/*.{css,scss}', { eager: true })\n`,
+                    map: null
+                };
+            }
+        },
+        {
+            name: 'metaowl:copy-assets',
+            apply: 'build',
+            closeBundle() {
+                if (!outDirResolved)
+                    return;
+                const projectRoot = process.cwd();
+                const xmlFiles = globSync([`${componentsDir}/**/*.xml`, `${pagesDir}/**/*.xml`, `${layoutsDir}/**/*.xml`]);
+                const mergedXml = mergeXmlFiles(xmlFiles);
+                const hash = createHash('sha256').update(mergedXml).digest('hex').slice(0, 8);
+                const hashedFilename = `templates.${hash}.xml`;
+                writeFileSync(resolve(outDirResolved, hashedFilename), mergedXml, 'utf-8');
+                const outputFiles = globSync(['**/*.html', '**/*.js'], { cwd: outDirResolved, absolute: true });
+                for (const file of outputFiles) {
+                    const content = readFileSync(file, 'utf-8');
+                    if (content.includes('/templates.xml')) {
+                        writeFileSync(file, content.replace(/\/templates\.xml/g, `/${hashedFilename}`), 'utf-8');
+                    }
+                }
+                const srcImages = resolve(projectRoot, root, 'assets', 'images');
+                if (existsSync(srcImages)) {
+                    cpSync(srcImages, resolve(outDirResolved, 'assets', 'images'), { recursive: true });
+                }
+            }
+        }
+    ];
+    return plugins;
+}
+export async function metaowlConfig(options = {}) {
+    const { server, preview, build, ...metaowlOptions } = options;
+    const plugins = await metaowlPlugin(metaowlOptions);
+    return {
+        server: { port: 3000, strictPort: true, host: true, ...server },
+        preview: { port: 4173, strictPort: true, ...preview },
+        ...(build ? { build } : {}),
+        plugins
+    };
+}

package/eslint.js

@@ -1,4 +1,6 @@
 import js from '@eslint/js'
+import tsParser from '@typescript-eslint/parser'
+import tsPlugin from '@typescript-eslint/eslint-plugin'
 import globals from 'globals'
 
 /**
@@ -41,6 +43,33 @@ export const eslintConfig = [
       'no-undef': 'off'
     }
   },
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      parser: tsParser,
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+        COMPONENTS: 'readonly'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin
+    },
+    rules: {
+      'no-unused-vars': 'off',
+      '@typescript-eslint/no-unused-vars': ['error', {
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_'
+      }],
+      'semi': ['error', 'never'],
+      'quotes': ['error', 'single'],
+      'comma-dangle': ['error', 'never'],
+      'no-undef': 'off'
+    }
+  },
   {
     ignores: [
       'node_modules/**',

package/package.json

@@ -1,22 +1,31 @@
 {
   "name": "metaowl",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Lightweight meta-framework for Odoo OWL — file-based routing, app mounting, Fetch helper, Cache, Meta tags, SSG generator, and a Vite plugin.",
   "type": "module",
-  "main": "index.js",
+  "main": "./build/runtime/index.js",
   "exports": {
-    ".": "./index.js",
-    "./vite": "./vite/plugin.js",
+    ".": "./build/runtime/index.js",
+    "./vite": "./build/runtime/vite/plugin.js",
     "./eslint": "./eslint.js",
     "./postcss": "./postcss.cjs"
   },
   "bin": {
-    "metaowl-create": "./bin/metaowl-create.js",
-    "metaowl-dev": "./bin/metaowl-dev.js",
-    "metaowl-build": "./bin/metaowl-build.js",
-    "metaowl-generate": "./bin/metaowl-generate.js",
-    "metaowl-lint": "./bin/metaowl-lint.js"
+    "metaowl-create": "./build/runtime/bin/metaowl-create.js",
+    "metaowl-dev": "./build/runtime/bin/metaowl-dev.js",
+    "metaowl-build": "./build/runtime/bin/metaowl-build.js",
+    "metaowl-generate": "./build/runtime/bin/metaowl-generate.js",
+    "metaowl-lint": "./build/runtime/bin/metaowl-lint.js"
   },
+  "files": [
+    "build/runtime",
+    "config",
+    "eslint.js",
+    "postcss.cjs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "keywords": [
     "owl",
     "odoo",
@@ -49,17 +58,26 @@
     "globals": "^13.24.0",
     "prettier": "3.5.1",
     "vite": "^8.0.0",
-    "vite-plugin-handlebars": "^2.0.0",
     "vite-tsconfig-paths": "^6.1.1"
   },
   "engines": {
     "node": ">=20.0.0"
   },
   "scripts": {
+    "clean:runtime": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('build/runtime', { recursive: true, force: true })\"",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "lint": "eslint . --ext .js,.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "release:check": "npm run typecheck && npm test",
+    "build:runtime": "npm run clean:runtime && tsc -p tsconfig.build.json && node --input-type=module -e \"import { chmodSync, readdirSync } from 'node:fs'; for (const entry of readdirSync('build/runtime/bin')) { if (entry.endsWith('.js')) chmodSync('build/runtime/bin/' + entry, 0o755); }\"",
+    "release:build": "npm run release:check && npm run build:runtime",
+    "release:pack": "npm run release:check && npm pack --dry-run",
+    "prepack": "npm run build:runtime"
   },
   "devDependencies": {
+    "@types/jsdom": "^28.0.1",
+    "@types/node": "^25.6.0",
     "jsdom": "^28.1.0",
     "vitest": "^4.1.0"
   }

package/CONTRIBUTING.md

@@ -1,49 +0,0 @@
-# Contributing to metaowl
-
-Thank you for considering a contribution! Here is how to get started.
-
-## Reporting Issues
-
-Before opening a new issue, please [search existing issues](https://github.com/dennisschott/metaowl/issues) to avoid duplicates. When filing a bug report, include:
-
-- metaowl version (`npm ls metaowl`)
-- Node.js version (`node --version`)
-- Minimal reproduction steps or a repository link
-- Expected vs. actual behaviour
-
-## Development Setup
-
-```bash
-git clone https://github.com/dennisschott/metaowl.git
-cd metaowl
-npm install
-```
-
-## Submitting a Pull Request
-
-1. **Open an issue first** to discuss significant changes before investing time in an implementation.
-2. Fork the repository and create a feature branch from `main`:
-   ```bash
-   git checkout -b feat/my-feature
-   ```
-3. Make your changes, keeping scope minimal and focused.
-4. Ensure the project is lint-clean:
-   ```bash
-   node bin/metaowl-lint.js
-   ```
-5. Commit using [Conventional Commits](https://www.conventionalcommits.org):
-   - `feat:` — new features
-   - `fix:` — bug fixes
-   - `docs:` — documentation only
-   - `chore:` — tooling, dependencies
-6. Push your branch and open a pull request against `main`.
-
-## Code Style
-
-- ES modules (`import`/`export`) throughout.
-- No semicolons; single quotes; no trailing commas (enforced by ESLint).
-- Keep public API surface minimal — prefer extending existing modules over adding new entry points.
-
-## License
-
-By contributing you agree that your contributions will be licensed under the [MIT License](LICENSE).

package/bin/metaowl-build.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-/**
- * metaowl build — lint then production build.
- */
-import { banner, metaowlRoot, resolveBin, run, success } from './utils.js'
-
-banner('build')
-run('Linting', `node "${metaowlRoot}/bin/metaowl-lint.js"`)
-run('Building', `"${resolveBin('vite')}" build`)
-success('Build complete')
-console.log()
-

package/bin/metaowl-dev.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-/**
- * metaowl dev — start the Vite development server.
- */
-import { execSync } from 'node:child_process'
-import { banner, cwd, resolveBin, step } from './utils.js'
-
-banner('dev')
-step('Starting development server...')
-console.log()
-
-execSync(`"${resolveBin('vite')}"`, { stdio: 'inherit', cwd })