metaowl 0.4.1 → 0.6.0

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,56 @@
 {
   "name": "metaowl",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Lightweight meta-framework for Odoo OWL — file-based routing, app mounting, Fetch helper, Cache, Meta tags, SSG generator, and a Vite plugin.",
+  "author": "Dennis Schott",
+  "license": "LGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dennisschott/metaowl"
+  },
+  "homepage": "https://metaowl.org",
+  "bugs": {
+    "url": "https://github.com/dennisschott/metaowl/issues"
+  },
   "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"
+  },
+  "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",
+    "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"
   },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "build/runtime",
+    "config",
+    "eslint.js",
+    "postcss.cjs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "keywords": [
     "owl",
     "odoo",
@@ -24,17 +58,7 @@
     "vite",
     "meta-framework"
   ],
-  "author": "Dennis Schott",
-  "license": "LGPL-3.0-only",
   "sideEffects": false,
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/dennisschott/metaowl"
-  },
-  "homepage": "https://metaowl.org",
-  "bugs": {
-    "url": "https://github.com/dennisschott/metaowl/issues"
-  },
   "dependencies": {
     "@eslint/js": "^9.20.1",
     "@odoo/owl": "^2.8.2",
@@ -51,15 +75,9 @@
     "vite": "^8.0.0",
     "vite-tsconfig-paths": "^6.1.1"
   },
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "lint": "eslint . --ext .js,.ts"
-  },
   "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 })

package/bin/metaowl-generate.js

@@ -1,339 +0,0 @@
-#!/usr/bin/env node
-/**
- * metaowl generate — SSG production build.
- *
- * Runs lint + vite build, then generates a static HTML file for every page:
- * - <title> and meta tags extracted statically from Meta.*() calls in the page JS
- * - Static HTML content auto-extracted from the page's OWL XML template,
- *   with OWL-specific syntax stripped (best-effort, no JS evaluated)
- *
- * pagesDir / outDir can be overridden in package.json under "metaowl":
- *   { "metaowl": { "pagesDir": "src/pages", "outDir": "dist" } }
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { globSync } from 'glob'
-import { banner, cwd, metaowlRoot, resolveBin, run, step, success, failure } from './utils.js'
-
-banner('generate')
-
-function escapeAttr(str) {
-  return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;')
-}
-
-/**
- * Statically extract Meta.*() call arguments from JS source.
- * Only works for string literals — dynamic values are skipped.
- *
- * Returns an object with the keys:
- *   title, description, keywords, author, canonical,
- *   ogTitle, ogDescription, ogImage, ogUrl, ogType, ogSiteName
- */
-function extractMetaFromJs(src) {
-  const meta = {}
-  const fns = [
-    'title', 'description', 'keywords', 'author', 'canonical',
-    'ogTitle', 'ogDescription', 'ogImage', 'ogUrl', 'ogType', 'ogSiteName',
-  ]
-  for (const fn of fns) {
-    const m = src.match(new RegExp(`Meta\\.${fn}\\s*\\(\\s*(['"\`])([^'"\`]+)\\1\\s*\\)`))
-    if (m) meta[fn] = m[2]
-  }
-  return meta
-}
-
-/**
- * Inject extracted meta values into the HTML head.
- * Returns the modified HTML string.
- */
-function injectMeta(html, meta) {
-  if (meta.title) {
-    html = html.replace(/<title>[^<]*<\/title>/, `<title>${escapeAttr(meta.title)}</title>`)
-  }
-  /** @param {string} selector @param {string} tag */
-  const injectTag = (selector, tag) => {
-    html = html.replace(new RegExp(`\\s*${selector}[^>]*>\\s*`, 'gi'), '')
-    html = html.replace('</head>', `  ${tag}\n  </head>`)
-  }
-  if (meta.description)
-    injectTag('<meta\\s+name="description"', `<meta name="description" content="${escapeAttr(meta.description)}">`)
-  if (meta.keywords)
-    injectTag('<meta\\s+name="keywords"', `<meta name="keywords" content="${escapeAttr(meta.keywords)}">`)
-  if (meta.author)
-    injectTag('<meta\\s+name="author"', `<meta name="author" content="${escapeAttr(meta.author)}">`)
-  if (meta.canonical)
-    injectTag('<link\\s+rel="canonical"', `<link rel="canonical" href="${escapeAttr(meta.canonical)}">`)
-  if (meta.ogTitle)
-    injectTag('<meta\\s+property="og:title"', `<meta property="og:title" content="${escapeAttr(meta.ogTitle)}">`)
-  if (meta.ogDescription)
-    injectTag('<meta\\s+property="og:description"', `<meta property="og:description" content="${escapeAttr(meta.ogDescription)}">`)
-  if (meta.ogImage)
-    injectTag('<meta\\s+property="og:image"', `<meta property="og:image" content="${escapeAttr(meta.ogImage)}">`)
-  if (meta.ogUrl)
-    injectTag('<meta\\s+property="og:url"', `<meta property="og:url" content="${escapeAttr(meta.ogUrl)}">`)
-  if (meta.ogType)
-    injectTag('<meta\\s+property="og:type"', `<meta property="og:type" content="${escapeAttr(meta.ogType)}">`)
-  if (meta.ogSiteName)
-    injectTag('<meta\\s+property="og:site_name"', `<meta property="og:site_name" content="${escapeAttr(meta.ogSiteName)}">`)
-  return html
-}
-
-// Read project config
-const pkg = JSON.parse(readFileSync(resolve(cwd, 'package.json'), 'utf-8'))
-const metaowlConfig = pkg.metaowl ?? {}
-const pagesDir = metaowlConfig.pagesDir ?? 'src/pages'
-const outDir = metaowlConfig.outDir ?? 'dist'
-
-// Derive URL route from a page file path
-function deriveRoute(pageFile) {
-  const rel = pageFile.replace(new RegExp(`^${pagesDir}[\\/]`), '')
-  const parts = rel.split('/').slice(0, -1)
-  if (parts.length === 1 && parts[0] === 'index') return '/'
-  return '/' + parts.join('/')
-}
-
-/**
- * Extracts the layout name from a page component JS file.
- * Looks for `static layout = 'layoutName'` or `@layout('layoutName')`.
- *
- * @param {string} pageFile - Absolute path to the page JS file
- * @returns {string|null} Layout name or null if not found
- */
-function extractLayoutName(pageFile) {
-  const jsSource = readFileSync(pageFile, 'utf-8')
-
-  // Match: static layout = 'layoutName' or static layout = "layoutName"
-  let match = jsSource.match(/static\s+layout\s*=\s*['"]([^'"]+)['"]/)
-  if (match) return match[1]
-
-  // Match: @layout('layoutName') or @layout("layoutName")
-  match = jsSource.match(/@layout\s*\(\s*['"]([^'"]+)['"]\s*\)/)
-  if (match) return match[1]
-
-  // Match: @defineLayout('layoutName', ...)
-  match = jsSource.match(/@defineLayout\s*\(\s*['"]([^'"]+)['"]/)
-  if (match) return match[1]
-
-  return 'default'
-}
-
-/**
- * Converts an OWL XML template to best-effort static HTML.
- * - Strips t-name on the root element
- * - Strips all t-* attributes
- * - Unwraps bare <t> elements (replaces with their inner content)
- * - Replaces PascalCase component tags with their template content
- * - Replaces t-slot="default" with provided page content
- * - Removes <templates> wrapper and root <t> elements
- *
- * @param {string} xml - OWL XML template
- * @param {string} [pageContent] - Optional page content to inject into t-slot="default"
- * @param {object} [options] - Options object
- * @param {Map<string, string>} [options.templateCache] - Cache of template name -> content
- */
-function xmlToStaticHtml(xml, pageContent = '', options = {}) {
-  const { templateCache } = options
-  let html = xml
-
-  // Remove <templates> wrapper
-  html = html.replace(/<templates>/g, '').replace(/<\/templates>/g, '')
-
-  // Remove root <t> elements (self-closing or with content)
-  // Match <t ...>...</t> at the start and end
-  html = html.replace(/^\s*<t[^>]*>/, '').replace(/<\/t>\s*$/, '')
-
-  // Remove t-name attribute from root
-  html = html.replace(/\s+t-name="[^"]*"/g, '')
-  // Remove all t-* attributes (handles both t-if="..." and bare t-else/t-else)
-  html = html.replace(/\s+t-[\w-]+(="[^"]*")?/g, '')
-  // Unwrap bare <t> wrapper elements (self-closing)
-  html = html.replace(/<t\s*\/>/g, '')
-  // Unwrap <t ...> ... </t> blocks — replace opening/closing tags with content
-  html = html.replace(/<t(?:\s[^>]*)?>([\s\S]*?)<\/t>/g, (_, inner) => inner)
-  // Replace t-slot="default" with page content (if provided)
-  if (pageContent) {
-    html = html.replace(/<t\s+t-slot="default"\s*\/?>/g, pageContent)
-    html = html.replace(/<t\s+t-slot="default"[^>]*>([\s\S]*?)<\/t>/g, pageContent)
-  }
-
-  // Replace PascalCase component tags with their template content (if available)
-  if (templateCache) {
-    // Keep replacing until no more changes (for nested components)
-    let previousHtml
-    do {
-      previousHtml = html
-      html = html.replace(/<([A-Z][A-Za-z0-9]*)\s*\/>/g, (match, componentName) => {
-        // Try different naming conventions
-        const templateNames = [
-          componentName,
-          componentName.charAt(0).toLowerCase() + componentName.slice(1),
-          componentName + 'Component',
-        ]
-        for (const name of templateNames) {
-          if (templateCache.has(name)) {
-            return templateCache.get(name)
-          }
-        }
-        return match // Keep original if not found
-      })
-      html = html.replace(/<([A-Z][A-Za-z0-9]*)(?:\s[^>]*)?>([\s\S]*?)<\/\1>/g, (match, componentName, innerContent) => {
-        const templateNames = [
-          componentName,
-          componentName.charAt(0).toLowerCase() + componentName.slice(1),
-          componentName + 'Component',
-        ]
-        for (const name of templateNames) {
-          if (templateCache.has(name)) {
-            return templateCache.get(name)
-          }
-        }
-        return match
-      })
-    } while (html !== previousHtml)
-  } else {
-    // No cache available, use comment stubs as fallback
-    html = html.replace(/<([A-Z][A-Za-z0-9]*)\s*\/>/g, '<!-- $1 -->')
-    html = html.replace(/<([A-Z][A-Za-z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, '<!-- $1 -->')
-  }
-
-  return html.trim()
-}
-
-// Build final HTML shell for a page
-function buildShell(baseHtml, pageFile) {
-  let html = baseHtml
-
-  // Extract meta tags from JS source (Meta.title(...), Meta.description(...) etc.)
-  const jsSource = readFileSync(resolve(cwd, pageFile), 'utf-8')
-  const meta = extractMetaFromJs(jsSource)
-  html = injectMeta(html, meta)
-
-  // Get the page's layout name
-  const layoutName = extractLayoutName(resolve(cwd, pageFile))
-  const layoutsDir = metaowlConfig.layoutsDir ?? 'src/layouts'
-  const componentsDir = metaowlConfig.componentsDir ?? 'src/components'
-
-  // Build template cache from all XML files (components, pages, layouts)
-  const templateCache = new Map()
-
-  // Scan component XML files
-  const componentXmlFiles = globSync(`${componentsDir}/**/*.xml`, { cwd })
-  for (const componentXmlFile of componentXmlFiles) {
-    const content = readFileSync(resolve(cwd, componentXmlFile), 'utf-8')
-    // Extract t-name values and their content: <t t-name="ComponentName">...content...</t>
-    const tNameMatches = content.matchAll(/<t\s+t-name="([^"]+)"[^>]*>([\s\S]*?)<\/t>/g)
-    for (const match of tNameMatches) {
-      const templateName = match[1]
-      const templateContent = match[2]
-      templateCache.set(templateName, templateContent)
-    }
-    // Also try to get the root element as the template (without t-name)
-    const rootMatch = content.match(/<templates>\s*<t[^>]*>([\s\S]*?)<\/t>\s*<\/templates>/)
-    if (rootMatch) {
-      // Try to derive component name from file path
-      const fileName = componentXmlFile.replace(/\.xml$/, '').split('/').pop()
-      if (fileName) {
-        templateCache.set(fileName, rootMatch[1])
-      }
-    }
-  }
-
-  // Also scan layout XML files for templates
-  const layoutXmlFiles = globSync(`${layoutsDir}/**/*.xml`, { cwd })
-  for (const layoutXmlFile of layoutXmlFiles) {
-    const content = readFileSync(resolve(cwd, layoutXmlFile), 'utf-8')
-    const tNameMatches = content.matchAll(/<t\s+t-name="([^"]+)"[^>]*>([\s\S]*?)<\/t>/g)
-    for (const match of tNameMatches) {
-      templateCache.set(match[1], match[2])
-    }
-  }
-
-  // Also scan page XML files for templates
-  const pageXmlFiles = globSync(`${pagesDir}/**/*.xml`, { cwd })
-  for (const pageXmlFile of pageXmlFiles) {
-    const content = readFileSync(resolve(cwd, pageXmlFile), 'utf-8')
-    const tNameMatches = content.matchAll(/<t\s+t-name="([^"]+)"[^>]*>([\s\S]*?)<\/t>/g)
-    for (const match of tNameMatches) {
-      templateCache.set(match[1], match[2])
-    }
-    // Try to get the root element as the template (without t-name)
-    const rootMatch = content.match(/<templates>\s*<t[^>]*>([\s\S]*?)<\/t>\s*<\/templates>/)
-    if (rootMatch) {
-      const fileName = pageXmlFile.replace(/\.xml$/, '').split('/').pop()
-      if (fileName) {
-        templateCache.set(fileName, rootMatch[1])
-      }
-    }
-  }
-
-  // Try to find and read the layout XML template
-  let finalContent = ''
-
-  // First, try to read the layout XML
-  const layoutXmlFile = resolve(cwd, layoutsDir, layoutName, `${layoutName.charAt(0).toUpperCase() + layoutName.slice(1)}Layout.xml`)
-  const layoutXmlExists = existsSync(layoutXmlFile)
-
-  // Read the page XML template
-  const pageXmlFile = resolve(cwd, pageFile.replace(/\.js$/, '.xml'))
-  const pageXmlExists = existsSync(pageXmlFile)
-
-  if (layoutXmlExists && pageXmlExists) {
-    // Read both layout and page templates
-    const layoutXmlContent = readFileSync(layoutXmlFile, 'utf-8')
-    const pageXmlContent = readFileSync(pageXmlFile, 'utf-8')
-
-    // Convert page XML to static HTML first
-    const pageStaticHtml = xmlToStaticHtml(pageXmlContent, '', { templateCache })
-
-    // Then inject into layout's t-slot="default"
-    finalContent = xmlToStaticHtml(layoutXmlContent, pageStaticHtml, { templateCache })
-  } else if (pageXmlExists) {
-    // No layout found, just use page content
-    const pageXmlContent = readFileSync(pageXmlFile, 'utf-8')
-    finalContent = xmlToStaticHtml(pageXmlContent, '', { templateCache })
-  }
-
-  // Inject the combined layout + page HTML
-  if (finalContent) {
-    html = html.replace(/(<div\s+id="metaowl"[^>]*>)(<\/div>)/, `$1${finalContent}$2`)
-  }
-
-  return html
-}
-
-// 1. Lint
-run('Linting', `node "${metaowlRoot}/bin/metaowl-lint.js"`)
-
-// 2. Vite build
-run('Building', `"${resolveBin('vite')}" build`)
-
-// 3. SSG post-processing
-step('Generating static pages...')
-console.log()
-const baseHtml = readFileSync(resolve(cwd, outDir, 'index.html'), 'utf-8')
-
-const pageFiles = globSync(`${pagesDir}/**/*.js`, { cwd })
-
-const seen = new Set()
-
-for (const pageFile of pageFiles) {
-  const route = deriveRoute(pageFile)
-  if (seen.has(route)) continue
-  seen.add(route)
-
-  const shell = buildShell(baseHtml, pageFile)
-
-  if (route === '/') {
-    writeFileSync(resolve(cwd, outDir, 'index.html'), shell)
-    console.log(`    /index.html`)
-  } else {
-    const destDir = resolve(cwd, outDir, route.slice(1))
-    mkdirSync(destDir, { recursive: true })
-    writeFileSync(resolve(destDir, 'index.html'), shell)
-    console.log(`    ${route}/index.html`)
-  }
-}
-
-console.log()
-success(`${seen.size} route(s) generated`)
-console.log()

package/bin/metaowl-lint.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-/**
- * metaowl lint — format with Prettier then lint with ESLint.
- *
- * Lint targets can be configured in package.json under `metaowl.lint`:
- *
- *   "metaowl": {
- *     "lint": ["src/app.js", "src/pages/**", "src/components/**"]
- *   }
- */
-import { execSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { globSync } from 'glob'
-import { banner, cwd, resolveBin, step, success, failure } from './utils.js'
-
-banner('lint')
-
-let lintTargets = null
-try {
-  const pkg = JSON.parse(readFileSync(resolve(cwd, 'package.json'), 'utf8'))
-  lintTargets = pkg?.metaowl?.lint ?? null
-} catch {
-  // no package.json or no metaowl config
-}
-
-const defaults = [
-  'src/metaowl.js',
-  'src/css.js',
-  'src/pages/**',
-  'src/components/**'
-]
-
-const candidates = lintTargets ?? defaults
-
-const existing = candidates.filter(pattern => {
-  if (existsSync(resolve(cwd, pattern))) return true
-  return globSync(pattern, { cwd }).length > 0
-})
-
-if (existing.length === 0) {
-  success('No lint targets found — skipping')
-  console.log()
-  process.exit(0)
-}
-
-const targets = existing.map(t => `"${t}"`).join(' ')
-
-step('Formatting with Prettier...')
-console.log()
-try {
-  execSync(`"${resolveBin('prettier')}" src --single-quote --no-semi --write`, { stdio: 'inherit', cwd })
-} catch {
-  failure('Prettier failed')
-  process.exit(1)
-}
-console.log()
-
-step('Linting with ESLint...')
-console.log()
-try {
-  execSync(`"${resolveBin('eslint')}" ${targets} --fix`, { stdio: 'inherit', cwd })
-} catch {
-  failure('ESLint failed')
-  process.exit(1)
-}
-console.log()
-
-success('Lint complete')
-console.log()
-