@adonisjs/assembler 5.9.4 → 6.0.0-0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright 2022 Harminder Virk, contributors
+Copyright (c) 2023 AdonisJS Framework
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export { Bundler } from './src/bundler.js';
+export { DevServer } from './src/dev_server.js';

package/build/index.js

@@ -0,0 +1,2 @@
+export { Bundler } from './src/bundler.js';
+export { DevServer } from './src/dev_server.js';

package/build/src/bundler.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+import type tsStatic from 'typescript';
+import { type Logger } from '@poppinss/cliui';
+import type { BundlerOptions } from './types.js';
+export declare class Bundler {
+    #private;
+    constructor(cwd: URL, ts: typeof tsStatic, options: BundlerOptions);
+    setLogger(logger: Logger): this;
+    bundle(stopOnError?: boolean, client?: 'npm' | 'yarn' | 'pnpm'): Promise<boolean>;
+}

package/build/src/bundler.js

@@ -0,0 +1,133 @@
+import fs from 'fs-extra';
+import slash from 'slash';
+import copyfiles from 'cpy';
+import { execa } from 'execa';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ConfigParser } from '@poppinss/chokidar-ts';
+import { cliui } from '@poppinss/cliui';
+const ui = cliui();
+export class Bundler {
+    #cwd;
+    #cwdPath;
+    #ts;
+    #logger = ui.logger;
+    #options;
+    get #colors() {
+        return this.#logger.getColors();
+    }
+    constructor(cwd, ts, options) {
+        this.#cwd = cwd;
+        this.#cwdPath = fileURLToPath(this.#cwd);
+        this.#ts = ts;
+        this.#options = options;
+    }
+    #getRelativeName(filePath) {
+        return slash(relative(this.#cwdPath, filePath));
+    }
+    async #cleanupBuildDirectory(outDir) {
+        await fs.remove(outDir);
+    }
+    async #runTsc() {
+        try {
+            await execa('tsc', [], {
+                cwd: this.#cwd,
+                preferLocal: true,
+                localDir: this.#cwd,
+                windowsHide: false,
+                buffer: false,
+                stdio: 'inherit',
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async #copyFiles(files, outDir) {
+        try {
+            await copyfiles(files, outDir, { cwd: this.#cwdPath });
+        }
+        catch (error) {
+            if (!error.message.includes("the file doesn't exist")) {
+                throw error;
+            }
+        }
+    }
+    async #copyMetaFiles(outDir, additionalFilesToCopy) {
+        const metaFiles = (this.#options.metaFiles || [])
+            .map((file) => file.pattern)
+            .concat(additionalFilesToCopy);
+        await this.#copyFiles(metaFiles, outDir);
+    }
+    async #copyAdonisRcFile(outDir) {
+        const existingContents = await fs.readJSON(join(this.#cwdPath, '.adonisrc.json'));
+        const compiledContents = Object.assign({}, existingContents, {
+            typescript: false,
+            lastCompiledAt: new Date().toISOString(),
+        });
+        await fs.outputJSON(join(outDir, '.adonisrc.json'), compiledContents, { spaces: 2 });
+    }
+    #getClientLockFile(client) {
+        switch (client) {
+            case 'npm':
+                return 'package-lock.json';
+            case 'yarn':
+                return 'yarn.lock';
+            case 'pnpm':
+                return 'pnpm-lock.yaml';
+        }
+    }
+    #getClientInstallCommand(client) {
+        switch (client) {
+            case 'npm':
+                return 'npm ci --omit="dev"';
+            case 'yarn':
+                return 'yarn install --production';
+            case 'pnpm':
+                return 'pnpm i --prod';
+        }
+    }
+    setLogger(logger) {
+        this.#logger = logger;
+        return this;
+    }
+    async bundle(stopOnError = true, client = 'npm') {
+        const { config } = new ConfigParser(this.#cwd, 'tsconfig.json', this.#ts).parse();
+        if (!config) {
+            return false;
+        }
+        const outDir = config.options.outDir || fileURLToPath(new URL('build/', this.#cwd));
+        this.#logger.info('cleaning up output directory', { suffix: this.#getRelativeName(outDir) });
+        await this.#cleanupBuildDirectory(outDir);
+        this.#logger.info('compiling typescript source', { suffix: 'tsc' });
+        const buildCompleted = await this.#runTsc();
+        await this.#copyFiles(['ace.js'], outDir);
+        if (!buildCompleted && stopOnError) {
+            await this.#cleanupBuildDirectory(outDir);
+            const instructions = ui
+                .sticker()
+                .fullScreen()
+                .drawBorder((borderChar, colors) => colors.red(borderChar));
+            instructions.add(this.#colors.red('Cannot complete the build process as there are TypeScript errors.'));
+            instructions.add(this.#colors.red('Use "--ignore-ts-errors" flag to ignore TypeScript errors and continue the build.'));
+            this.#logger.logError(instructions.prepare());
+            return false;
+        }
+        const pkgFiles = ['package.json', this.#getClientLockFile(client)];
+        this.#logger.info('copying meta files to the output directory');
+        await this.#copyMetaFiles(outDir, pkgFiles);
+        this.#logger.info('copying .adonisrc.json file to the output directory');
+        await this.#copyAdonisRcFile(outDir);
+        this.#logger.success('build completed');
+        this.#logger.log('');
+        ui.instructions()
+            .useRenderer(this.#logger.getRenderer())
+            .heading('Run the following commands to start the server in production')
+            .add(this.#colors.cyan(`cd ${this.#getRelativeName(outDir)}`))
+            .add(this.#colors.cyan(this.#getClientInstallCommand(client)))
+            .add(this.#colors.cyan('node bin/server.js'))
+            .render();
+        return true;
+    }
+}

package/build/src/dev_server.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+import type tsStatic from 'typescript';
+import { type Logger } from '@poppinss/cliui';
+import type { DevServerOptions } from './types.js';
+export declare class DevServer {
+    #private;
+    constructor(cwd: URL, options: DevServerOptions);
+    setLogger(logger: Logger): this;
+    start(): Promise<void>;
+    startAndWatch(ts: typeof tsStatic, options?: {
+        poll: boolean;
+    }): Promise<void>;
+}

package/build/src/dev_server.js

@@ -0,0 +1,189 @@
+import getPort from 'get-port';
+import picomatch from 'picomatch';
+import { cliui } from '@poppinss/cliui';
+import { EnvLoader, EnvParser } from '@adonisjs/env';
+import { run } from './run.js';
+import { watch } from './watch.js';
+const ui = cliui();
+export class DevServer {
+    #cwd;
+    #logger = ui.logger;
+    #options;
+    #isWatching = false;
+    #scriptFile = 'bin/server.js';
+    #httpServerProcess;
+    #isMetaFileWithReloadsEnabled;
+    #isMetaFileWithReloadsDisabled;
+    get #colors() {
+        return this.#logger.getColors();
+    }
+    constructor(cwd, options) {
+        this.#cwd = cwd;
+        this.#options = options;
+        this.#isMetaFileWithReloadsEnabled = picomatch((this.#options.metaFiles || [])
+            .filter(({ reloadServer }) => reloadServer === true)
+            .map(({ pattern }) => pattern));
+        this.#isMetaFileWithReloadsDisabled = picomatch((this.#options.metaFiles || [])
+            .filter(({ reloadServer }) => reloadServer !== true)
+            .map(({ pattern }) => pattern));
+    }
+    #isDotEnvFile(filePath) {
+        if (filePath === '.env') {
+            return true;
+        }
+        return filePath.includes('.env.');
+    }
+    #isRcFile(filePath) {
+        return filePath === '.adonisrc.json';
+    }
+    #isAdonisJSReadyMessage(message) {
+        return (message !== null &&
+            typeof message === 'object' &&
+            'isAdonisJS' in message &&
+            'environment' in message &&
+            message.environment === 'web');
+    }
+    #clearScreen() {
+        if (this.#options.clearScreen) {
+            process.stdout.write('\u001Bc');
+        }
+    }
+    async #getPort() {
+        if (process.env.PORT) {
+            return getPort({ port: Number(process.env.PORT) });
+        }
+        const files = await new EnvLoader(this.#cwd).load();
+        for (let file of files) {
+            const envVariables = new EnvParser(file.contents).parse();
+            if (envVariables.PORT) {
+                return getPort({ port: Number(envVariables.PORT) });
+            }
+        }
+        return getPort({ port: 3333 });
+    }
+    #startHTTPServer(port) {
+        this.#httpServerProcess = run(this.#cwd, {
+            script: this.#scriptFile,
+            env: { PORT: port, ...this.#options.env },
+            nodeArgs: this.#options.nodeArgs,
+            scriptArgs: this.#options.scriptArgs,
+        });
+        this.#httpServerProcess.on('message', (message) => {
+            if (this.#isAdonisJSReadyMessage(message)) {
+                ui.sticker()
+                    .useColors(this.#colors)
+                    .useRenderer(this.#logger.getRenderer())
+                    .add(`Server address: ${this.#colors.cyan(`http://${message.host}:${message.port}`)}`)
+                    .add(`File system watcher: ${this.#colors.cyan(`${this.#isWatching ? 'enabled' : 'disabled'}`)}`)
+                    .render();
+            }
+        });
+        this.#httpServerProcess.on('error', (error) => {
+            this.#logger.warning('unable to connect to underlying HTTP server process');
+            this.#logger.fatal(error);
+        });
+        this.#httpServerProcess.on('close', (exitCode) => {
+            this.#logger.warning(`underlying HTTP server closed with status code "${exitCode}"`);
+            this.#logger.info('watching file system and waiting for application to recover');
+        });
+    }
+    #restart(port) {
+        if (this.#httpServerProcess) {
+            this.#httpServerProcess.removeAllListeners();
+            this.#httpServerProcess.kill('SIGKILL');
+        }
+        this.#startHTTPServer(port);
+    }
+    setLogger(logger) {
+        this.#logger = logger;
+        return this;
+    }
+    async start() {
+        this.#clearScreen();
+        this.#logger.info('starting HTTP server...');
+        this.#startHTTPServer(String(await this.#getPort()));
+    }
+    async startAndWatch(ts, options) {
+        const port = String(await this.#getPort());
+        this.#isWatching = true;
+        this.#clearScreen();
+        this.#logger.info('starting HTTP server...');
+        this.#startHTTPServer(port);
+        const output = watch(this.#cwd, ts, options || {});
+        if (!output) {
+            return;
+        }
+        output.watcher.on('watcher:ready', () => {
+            this.#logger.info('watching file system for changes...');
+        });
+        output.watcher.on('source:add', ({ relativePath }) => {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+            this.#restart(port);
+        });
+        output.watcher.on('source:change', ({ relativePath }) => {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+            this.#restart(port);
+        });
+        output.watcher.on('source:unlink', ({ relativePath }) => {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+            this.#restart(port);
+        });
+        output.watcher.on('add', ({ relativePath }) => {
+            if (this.#isDotEnvFile(relativePath) || this.#isRcFile(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+            }
+        });
+        output.watcher.on('change', ({ relativePath }) => {
+            if (this.#isDotEnvFile(relativePath) || this.#isRcFile(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+            }
+        });
+        output.watcher.on('unlink', ({ relativePath }) => {
+            if (this.#isDotEnvFile(relativePath) || this.#isRcFile(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+            }
+        });
+    }
+}

package/build/src/run.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { RunOptions } from './types.js';
+export declare function run(cwd: string | URL, options: RunOptions): import("execa").ExecaChildProcess<string>;

package/build/src/run.js

@@ -0,0 +1,19 @@
+import { execaNode } from 'execa';
+const DEFAULT_NODE_ARGS = [
+    '--loader=ts-node/esm',
+    '--no-warnings',
+    '--experimental-import-meta-resolve',
+];
+export function run(cwd, options) {
+    const childProces = execaNode(options.script, options.scriptArgs, {
+        nodeOptions: DEFAULT_NODE_ARGS.concat(options.nodeArgs),
+        preferLocal: true,
+        windowsHide: false,
+        localDir: cwd,
+        cwd,
+        buffer: false,
+        stdio: 'inherit',
+        env: options.env,
+    });
+    return childProces;
+}

package/build/src/types.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" resolution-mode="require"/>
+export type RunOptions = {
+    script: string;
+    scriptArgs: string[];
+    nodeArgs: string[];
+    env?: NodeJS.ProcessEnv;
+};
+export type WatchOptions = {
+    poll?: boolean;
+};
+export type DevServerOptions = {
+    scriptArgs: string[];
+    nodeArgs: string[];
+    clearScreen?: boolean;
+    env?: NodeJS.ProcessEnv;
+    metaFiles?: {
+        pattern: string;
+        reloadServer: boolean;
+    }[];
+};
+export type BundlerOptions = {
+    metaFiles?: {
+        pattern: string;
+        reloadServer: boolean;
+    }[];
+};

package/build/src/watch.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+import type tsStatic from 'typescript';
+import { Watcher } from '@poppinss/chokidar-ts';
+import type { WatchOptions } from './types.js';
+export declare function watch(cwd: string | URL, ts: typeof tsStatic, options: WatchOptions): {
+    watcher: Watcher;
+    chokidar: import("chokidar").FSWatcher;
+} | undefined;

package/build/src/watch.js

@@ -0,0 +1,18 @@
+import { fileURLToPath } from 'node:url';
+import { ConfigParser, Watcher } from '@poppinss/chokidar-ts';
+export function watch(cwd, ts, options) {
+    const { config, error } = new ConfigParser(cwd, 'tsconfig.json', ts).parse();
+    if (error) {
+        const compilerHost = ts.createCompilerHost({});
+        console.log(ts.formatDiagnosticsWithColorAndContext([error], compilerHost));
+        return;
+    }
+    if (config.errors.length) {
+        const compilerHost = ts.createCompilerHost({});
+        console.log(ts.formatDiagnosticsWithColorAndContext(config.errors, compilerHost));
+        return;
+    }
+    const watcher = new Watcher(typeof cwd === 'string' ? cwd : fileURLToPath(cwd), config);
+    const chokidar = watcher.watch(['.'], { usePolling: options.poll });
+    return { watcher, chokidar };
+}

package/package.json

@@ -1,135 +1,87 @@
 {
   "name": "@adonisjs/assembler",
-  "version": "5.9.4",
-  "description": "Core commands to compiler and build AdonisJs project",
-  "main": "build/ace-manifest.json",
+  "version": "6.0.0-0",
+  "description": "Provides utilities to run AdonisJS development server and build project for production",
+  "main": "build/index.js",
+  "type": "module",
   "files": [
-    "build/commands",
-    "build/config",
-    "build/templates",
     "build/src",
-    "build/register.js",
-    "build/register.d.ts",
-    "build/ace-manifest.json"
+    "build/index.d.ts",
+    "build/index.js"
   ],
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types.js"
+  },
   "scripts": {
-    "mrm": "mrm --preset=@adonisjs/mrm-preset",
     "pretest": "npm run lint",
-    "test": "cross-env FORCE_COLOR=true node -r @adonisjs/require-ts/build/register ./bin/test.ts",
+    "test": "cross-env NODE_DEBUG=adonisjs:assembler c8 npm run vscode:test",
     "lint": "eslint . --ext=.ts",
     "clean": "del-cli build",
     "compile": "npm run lint && npm run clean && tsc",
-    "build": "npm run compile && node build/bin/index.js && copyfiles \"templates/**\" build",
-    "commit": "git-cz",
-    "release": "np --message=\"chore(release): %s\"",
+    "build": "npm run compile",
+    "release": "np",
     "version": "npm run build",
-    "sync-labels": "github-label-sync --labels ./node_modules/@adonisjs/mrm-preset/gh-labels.json adonisjs/assembler",
+    "sync-labels": "github-label-sync --labels .github/labels.json adonisjs/assembler",
     "format": "prettier --write .",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/adonisjs/assembler.git"
+    "prepublishOnly": "npm run build",
+    "vscode:test": "node --loader=ts-node/esm bin/test.ts"
   },
   "keywords": [
     "adonisjs",
-    "boot",
     "build",
     "ts"
   ],
   "author": "virk,adonisjs",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/adonisjs/assembler/issues"
-  },
-  "homepage": "https://github.com/adonisjs/assembler#readme",
   "devDependencies": {
-    "@adonisjs/ace": "^11.3.1",
-    "@adonisjs/core": "^5.8.9",
-    "@adonisjs/mrm-preset": "^5.0.3",
-    "@japa/assert": "^1.3.6",
-    "@japa/run-failed-tests": "^1.1.0",
-    "@japa/runner": "^2.2.2",
-    "@japa/spec-reporter": "^1.3.2",
+    "@commitlint/cli": "^17.4.4",
+    "@commitlint/config-conventional": "^17.4.4",
+    "@japa/assert": "^1.4.1",
+    "@japa/file-system": "^1.0.1",
+    "@japa/run-failed-tests": "^1.1.1",
+    "@japa/runner": "^2.5.1",
+    "@japa/spec-reporter": "^1.3.3",
+    "@poppinss/cliui": "^6.1.1-0",
     "@poppinss/dev-utils": "^2.0.3",
-    "@types/node": "^18.11.9",
-    "commitizen": "^4.2.5",
+    "@swc/core": "^1.3.36",
+    "@types/node": "^18.14.1",
+    "c8": "^7.13.0",
     "copyfiles": "^2.4.1",
     "cross-env": "^7.0.3",
-    "cz-conventional-changelog": "^3.3.0",
     "del-cli": "^5.0.0",
-    "eslint": "^8.27.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-adonis": "^2.1.1",
+    "eslint": "^8.34.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-adonis": "^3.0.3",
     "eslint-plugin-prettier": "^4.2.1",
     "github-label-sync": "^2.2.0",
-    "husky": "^8.0.2",
-    "mrm": "^4.1.13",
-    "np": "^7.6.2",
-    "prettier": "^2.7.1",
-    "typescript": "^4.9.3"
-  },
-  "nyc": {
-    "exclude": [
-      "test"
-    ],
-    "extension": [
-      ".ts"
-    ]
-  },
-  "husky": {
-    "hooks": {
-      "commit-msg": "node ./node_modules/@adonisjs/mrm-preset/validateCommit/conventional/validate.js"
-    }
-  },
-  "config": {
-    "commitizen": {
-      "path": "cz-conventional-changelog"
-    }
-  },
-  "np": {
-    "contents": ".",
-    "anyBranch": false
+    "husky": "^8.0.3",
+    "np": "^7.6.3",
+    "p-event": "^5.0.1",
+    "prettier": "^2.8.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@adonisjs/application": "^5.2.5",
-    "@adonisjs/env": "^3.0.9",
-    "@adonisjs/ioc-transformer": "^2.3.4",
-    "@adonisjs/require-ts": "^2.0.13",
-    "@adonisjs/sink": "^5.4.2",
-    "@poppinss/chokidar-ts": "^3.3.5",
-    "@poppinss/cliui": "^3.0.5",
-    "@poppinss/utils": "^5.0.0",
-    "cpy": "^8.1.2",
-    "emittery": "^0.13.1",
-    "execa": "^5.1.1",
-    "fs-extra": "^10.1.0",
-    "get-port": "^5.1.1",
-    "glob-parent": "^6.0.2",
-    "has-yarn": "^2.1.0",
+    "@adonisjs/env": "^4.2.0-0",
+    "@poppinss/chokidar-ts": "^4.0.0-0",
+    "@types/fs-extra": "^11.0.1",
+    "@types/picomatch": "^2.3.0",
+    "cpy": "^9.0.1",
+    "execa": "^7.0.0",
+    "fs-extra": "^11.1.0",
+    "get-port": "^6.1.2",
     "picomatch": "^2.3.1",
-    "slash": "^3.0.0"
+    "slash": "^5.0.0"
   },
-  "peerDependencies": {
-    "@adonisjs/core": "^5.1.0"
-  },
-  "publishConfig": {
-    "access": "public",
-    "tag": "latest"
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/adonisjs/assembler.git"
   },
-  "mrmConfig": {
-    "core": true,
-    "license": "MIT",
-    "services": [
-      "github-actions"
-    ],
-    "minNodeVersion": "14.15.4",
-    "probotApps": [
-      "stale",
-      "lock"
-    ],
-    "runGhActionsOnWindows": true
+  "bugs": {
+    "url": "https://github.com/adonisjs/assembler/issues"
   },
+  "homepage": "https://github.com/adonisjs/assembler#readme",
   "eslintConfig": {
     "extends": [
       "plugin:adonis/typescriptPackage",
@@ -159,5 +111,31 @@
     "bracketSpacing": true,
     "arrowParens": "always",
     "printWidth": 100
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "next",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**",
+      "build/**",
+      "examples/**"
+    ]
   }
 }