@apollion-dsi/scripts 0.8.1 → 0.9.0

package/lib/utils/resolveBin.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBin = resolveBin;
+const module_1 = require("module");
+const path_1 = __importDefault(require("path"));
+/**
+ * Resolve the absolute path to a dependency's CLI entrypoint as declared
+ * in its `package.json#bin`. Works for packages whose `exports` map
+ * blocks `require.resolve('<pkg>/bin/...')` (e.g. eslint 9+).
+ *
+ * @param pkgName - dependency name (e.g. `'eslint'`, `'prettier'`)
+ * @param binName - bin name when `package.json#bin` is an object map.
+ *   Defaults to `pkgName`.
+ * @param fromPath - directory to resolve `pkgName` from. Defaults to
+ *   this file's directory so production calls walk up from
+ *   `@apollion-dsi/scripts`'s install location.
+ */
+function resolveBin(pkgName, binName = pkgName, fromPath = __dirname) {
+    const req = (0, module_1.createRequire)(path_1.default.join(fromPath, 'noop.js'));
+    const pkgJsonPath = req.resolve(`${pkgName}/package.json`);
+    const pkgJson = req(pkgJsonPath);
+    const binField = pkgJson.bin;
+    if (!binField) {
+        throw new Error(`Package "${pkgName}" has no "bin" field in package.json`);
+    }
+    const relBin = typeof binField === 'string' ? binField : binField[binName];
+    if (!relBin) {
+        throw new Error(`Package "${pkgName}" has no bin named "${binName}"`);
+    }
+    return path_1.default.resolve(path_1.default.dirname(pkgJsonPath), relBin);
+}
+//# sourceMappingURL=resolveBin.js.map

package/lib/utils/resolveBin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveBin.js","sourceRoot":"","sources":["../../src/utils/resolveBin.ts"],"names":[],"mappings":";;;;;AAeA,gCAoBC;AAnCD,mCAAuC;AACvC,gDAAwB;AAExB;;;;;;;;;;;GAWG;AACH,SAAgB,UAAU,CAAC,OAAe,EAAE,UAAkB,OAAO,EAAE,WAAmB,SAAS;IACjG,MAAM,GAAG,GAAG,IAAA,sBAAa,EAAC,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;IAE1D,MAAM,WAAW,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,OAAO,eAAe,CAAC,CAAC;IAE3D,MAAM,OAAO,GAAG,GAAG,CAAC,WAAW,CAA8C,CAAC;IAE9E,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAE7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,YAAY,OAAO,sCAAsC,CAAC,CAAC;IAC7E,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAE3E,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,YAAY,OAAO,uBAAuB,OAAO,GAAG,CAAC,CAAC;IACxE,CAAC;IAED,OAAO,cAAI,CAAC,OAAO,CAAC,cAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;AACzD,CAAC"}

package/llms.txt

@@ -15,11 +15,31 @@ behind four commands: `create`, `dev`, `build`, `test`.
 | `dev` | webpack-dev-server + HMR (react-refresh) at :3000 |
 | `build` | Production bundle to `build/` |
 | `test` | Jest 30 in watch mode against changed files |
+| `lint` | ESLint over `src` w/ Apollion config (alias for `eslint src --ext ts,tsx --quiet`) |
+| `prettier` | Prettier `--check` over `src/**/*.{ts,tsx,json,css,md}` |
+| `check-types` (alias `tsc`) | `tsc --noEmit` against the consumer's tsconfig |
+| `audit` | `yarn npm audit --severity moderate --no-deprecations` (falls back to `npm audit --audit-level=moderate`) |
+| `validate` | Pre-merge gate: `check-types` + `prettier` + `lint` in parallel, then `test --watchAll=false`. `--skip=lint,prettier` to drop steps. |
 
-Use via `package.json#scripts`:
+Every command accepts pass-through args — `scripts lint -- --fix`,
+`scripts prettier -- --write src/`, `scripts check-types -- -p tsconfig.build.json`, etc.
+
+Use via `package.json#scripts` — the whole consumer file becomes thin:
 
 ```json
-{ "scripts": { "dev": "scripts dev", "build": "scripts build", "test": "scripts test" } }
+{
+  "scripts": {
+    "dev": "scripts dev",
+    "build": "scripts build",
+    "test": "scripts test",
+    "lint": "scripts lint",
+    "lint:fix": "scripts lint -- --fix",
+    "prettier": "scripts prettier",
+    "check-types": "scripts check-types",
+    "audit-dependencies": "scripts audit",
+    "validate": "scripts validate"
+  }
+}
 ```
 
 ## Stack (hidden from consumer)
@@ -28,19 +48,48 @@ Use via `package.json#scripts`:
 - `babel-plugin-relay` + `babel-plugin-styled-components`
 - `react-refresh` for HMR
 - Jest 30 + ts-jest + `@testing-library/react`
+- ESLint 9 (`@apollion-dsi/eslint-config`) + Prettier 3
 - Peer: **TypeScript 6.x**
 
+Consumers pull *only* `@apollion-dsi/scripts` for tooling — eslint, prettier,
+jest, babel et al. arrive transitively. The consumer's `package.json#scripts`
+should only reference `scripts <cmd>`.
+
 ## Invariants
 
 * **Yarn only** (consumer template uses Yarn 4 Berry).
 * **No webpack config exposed.** If you need a config escape hatch,
   open a ROADMAP entry — the point of this package is to not have one.
 * **TypeScript 6 strict** in the template — non-negotiable.
+* **Template tsconfig modern, never legacy.** `target: es2020`,
+  `moduleResolution: bundler`, `jsx: react-jsx`. No `es5`, no `node10`,
+  no classic JSX — both warn under TS 6.0 (`TS5107`) and break in TS 7.
+
+## tsconfig.base.json (consumer-facing)
+
+`@apollion-dsi/scripts` exposes a modern TS base config. Consumers
+extend it instead of copying values:
+
+```jsonc
+// tsconfig.json
+{
+  "extends": "@apollion-dsi/scripts/tsconfig.base.json",
+  "include": ["src"]
+}
+```
+
+The base sets `target: es2020`, `module: esnext`,
+`moduleResolution: bundler`, `jsx: react-jsx` (automatic runtime — no
+`import React` needed for JSX), `strict`, `isolatedModules`,
+`noEmit`. Overriding any field is fine; the goal is a defaultful SSOT,
+not a lock-in.
 
 ## Files
 
 - `lib/bin.js` — CLI entry (resolved by `package.json#bin`).
 - `lib/index.js` — programmatic entry.
+- `tsconfig.base.json` — exported via `package.json#exports` for
+  consumer `extends`.
 - `src/` — TS sources.
 - `scripts/validate.sh` — workspace `validate` step.
 

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@apollion-dsi/scripts",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Apollion Framework CLI",
   "main": "lib/index.js",
   "bin": "lib/bin.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./tsconfig.base.json": "./tsconfig.base.json",
+    "./package.json": "./package.json"
+  },
   "scripts": {
     "prepare": "yarn build",
     "audit-dependencies": "yarn npm audit --severity moderate --no-deprecations",
@@ -19,7 +24,7 @@
     "coverage": "jest --coverage",
     "validate:tests": "jest --coverage",
     "build": "tsc -p .",
-    "release": "yarn build && changeset publish"
+    "release": "yarn build && yarn changeset publish"
   },
   "keywords": [],
   "author": "Apollion DS Team",
@@ -47,6 +52,7 @@
     "detect-port": "2.1.0",
     "dotenv": "17.4.2",
     "dotenv-expand": "13.0.0",
+    "eslint": "9.29.0",
     "fork-ts-checker-webpack-plugin": "9.1.0",
     "fs-extra": "11.3.5",
     "git-revision-webpack-plugin": "5.0.0",
@@ -56,6 +62,7 @@
     "jest": "30.4.2",
     "jest-cli": "30.4.2",
     "jest-environment-node": "^30.4.1",
+    "prettier": "3.8.3",
     "react-refresh": "0.18.0",
     "resolve": "1.22.12",
     "semver": "7.8.0",
@@ -74,9 +81,7 @@
   "devDependencies": {
     "@testing-library/dom": "10.4.1",
     "@types/jest": "30.0.0",
-    "eslint": "9.29.0",
     "npm-run-all": "4.1.5",
-    "prettier": "3.8.3",
     "react": "19.2.6",
     "react-dom": "19.2.6",
     "styled-components": "6.4.1",

package/src/__tests__/resolveBin.test.ts

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { resolveBin } from '../utils/resolveBin';
+
+describe('resolveBin', () => {
+  let tmpRoot: string;
+
+  beforeEach(() => {
+    tmpRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'apollion-scripts-resolveBin-')));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  function makeFakePkg(name: string, binField: unknown, binFiles: string[] = []): void {
+    const pkgDir = path.join(tmpRoot, 'node_modules', name);
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({ name, version: '0.0.0', bin: binField }));
+
+    for (const file of binFiles) {
+      const target = path.join(pkgDir, file);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, '#!/usr/bin/env node\n');
+    }
+  }
+
+  it('resolves a string-style bin field', () => {
+    makeFakePkg('faketool-a', './bin/cli.js', ['bin/cli.js']);
+
+    const resolved = resolveBin('faketool-a', 'faketool-a', tmpRoot);
+
+    expect(resolved).toBe(path.join(tmpRoot, 'node_modules', 'faketool-a', 'bin', 'cli.js'));
+  });
+
+  it('resolves a map-style bin field via the pkg name by default', () => {
+    makeFakePkg('faketool-b', { 'faketool-b': './bin/main.js', other: './bin/other.js' }, [
+      'bin/main.js',
+      'bin/other.js',
+    ]);
+
+    const resolved = resolveBin('faketool-b', 'faketool-b', tmpRoot);
+
+    expect(resolved).toBe(path.join(tmpRoot, 'node_modules', 'faketool-b', 'bin', 'main.js'));
+  });
+
+  it('resolves a map-style bin field via an explicit alternative name', () => {
+    makeFakePkg('faketool-c', { 'faketool-c': './bin/main.js', alt: './bin/alt.js' }, ['bin/main.js', 'bin/alt.js']);
+
+    const resolved = resolveBin('faketool-c', 'alt', tmpRoot);
+
+    expect(resolved).toBe(path.join(tmpRoot, 'node_modules', 'faketool-c', 'bin', 'alt.js'));
+  });
+
+  it('throws if the package has no bin field', () => {
+    makeFakePkg('faketool-d', undefined);
+
+    expect(() => resolveBin('faketool-d', 'faketool-d', tmpRoot)).toThrow(/no "bin" field/);
+  });
+
+  it('throws if the requested bin name is missing from the map', () => {
+    makeFakePkg('faketool-e', { 'faketool-e': './bin/main.js' }, ['bin/main.js']);
+
+    expect(() => resolveBin('faketool-e', 'missing', tmpRoot)).toThrow(/no bin named "missing"/);
+  });
+});

package/src/bin.ts

@@ -18,10 +18,18 @@ notifier.notify({
   )} \nRun ${chalk.cyan('yarn add {packageName}')} to update.`,
 });
 
+const COMMAND_ALIASES: Record<string, string> = {
+  tsc: 'check-types',
+};
+
+const SUPPORTED_COMMANDS = new Set(['build', 'dev', 'test', 'lint', 'prettier', 'check-types', 'audit', 'validate']);
+
 (async (cmd: string[]) => {
-  const [command, ...options] = cmd;
+  const [rawCommand, ...options] = cmd;
+
+  const command = COMMAND_ALIASES[rawCommand] ?? rawCommand;
 
-  if (['build', 'dev', 'test'].includes(command)) {
+  if (SUPPORTED_COMMANDS.has(command)) {
     const result = spawn.sync(process.execPath, [require.resolve(`./command/${command}`), ...options], {
       stdio: 'inherit',
     });
@@ -35,7 +43,7 @@ notifier.notify({
     return process.exit(0);
   }
 
-  console.log(`${chalk.red('Commando não reconhecido:')} ${chalk.yellow(command)}`);
+  console.log(`${chalk.red('Commando não reconhecido:')} ${chalk.yellow(rawCommand)}`);
 
   process.exit(1);
 })(process.argv.slice(2));

package/src/command/audit.ts

@@ -0,0 +1,46 @@
+import spawn from 'cross-spawn';
+
+/**
+ * `scripts audit` — delegates to the active package manager's audit
+ * command. Defaults match the Apollion ecosystem standard
+ * (`severity moderate`, no deprecation noise). User-supplied args are
+ * appended.
+ *
+ * Resolution order:
+ *   1. yarn berry (>=2) — `yarn npm audit --severity moderate --no-deprecations`
+ *   2. yarn classic (1.x) — `yarn audit --level moderate`
+ *   3. npm fallback — `npm audit --audit-level=moderate`
+ */
+function probeYarnMajor(): number | null {
+  const probe = spawn.sync('yarn', ['--version'], { encoding: 'utf8' });
+
+  if (probe.status !== 0 || !probe.stdout) {
+    return null;
+  }
+
+  const major = Number.parseInt(String(probe.stdout).trim().split('.')[0], 10);
+
+  return Number.isNaN(major) ? null : major;
+}
+
+const userArgs = process.argv.slice(2);
+
+const yarnMajor = probeYarnMajor();
+
+let command: string;
+let baseArgs: string[];
+
+if (yarnMajor !== null && yarnMajor >= 2) {
+  command = 'yarn';
+  baseArgs = ['npm', 'audit', '--severity', 'moderate', '--no-deprecations'];
+} else if (yarnMajor !== null) {
+  command = 'yarn';
+  baseArgs = ['audit', '--level', 'moderate'];
+} else {
+  command = 'npm';
+  baseArgs = ['audit', '--audit-level=moderate'];
+}
+
+const result = spawn.sync(command, [...baseArgs, ...userArgs], { stdio: 'inherit' });
+
+process.exit(result.status ?? 1);

package/src/command/check-types.ts

@@ -0,0 +1,18 @@
+import spawn from 'cross-spawn';
+
+import { resolveBin } from '../utils/resolveBin';
+
+/**
+ * `scripts check-types` (alias `scripts tsc`) — runs `tsc --noEmit`
+ * resolving the consumer's TypeScript install (peerDep). Extra args
+ * pass through verbatim.
+ */
+const tscBin = resolveBin('typescript', 'tsc');
+
+const userArgs = process.argv.slice(2);
+
+const args = userArgs.length > 0 ? userArgs : ['--noEmit'];
+
+const result = spawn.sync(process.execPath, [tscBin, ...args], { stdio: 'inherit' });
+
+process.exit(result.status ?? 1);

package/src/command/create/helper.ts

@@ -21,7 +21,6 @@ export const templateDependencies = [
   '@apollion-dsi/core',
   '@apollion-dsi/scripts',
   '@apollion-dsi/eslint-config',
-  'audit-ci',
 ];
 
 export async function projectNameInput() {

package/src/command/create/index.ts

@@ -81,11 +81,13 @@ async function createPackageJson(config) {
         start: 'scripts dev',
         build: 'scripts build',
         test: 'scripts test -- --config=jest.config.js',
-        lint: 'eslint --quiet src --ext ts,tsx',
-        'lint:full': 'eslint src --ext ts,tsx',
-        'lint:fix': 'eslint --fix src --ext ts,tsx',
-        'prettier:write': 'prettier src/ --write',
-        'audit-dependencies': 'audit-ci --config audit-ci.json',
+        lint: 'scripts lint',
+        'lint:fix': 'scripts lint --fix',
+        prettier: 'scripts prettier',
+        'prettier:write': 'scripts prettier --write',
+        'check-types': 'scripts check-types',
+        'audit-dependencies': 'scripts audit',
+        validate: 'scripts validate',
       },
       husky: {
         hooks: {

package/src/command/lint.ts

@@ -0,0 +1,31 @@
+import spawn from 'cross-spawn';
+
+import { resolveBin } from '../utils/resolveBin';
+
+/**
+ * `scripts lint` — ESLint over `src` with `--quiet`. ESLint 9 flat
+ * config uses `eslint.config.js#files` for filtering (no `--ext`).
+ *
+ * If the consumer passes any path-like arg, they own the invocation
+ * entirely. Flag-only invocations (e.g. `scripts lint --fix`) keep the
+ * default `src` target so the common case Just Works.
+ */
+const eslintBin = resolveBin('eslint');
+
+const userArgs = process.argv.slice(2);
+
+const userProvidedPath = userArgs.some((a) => !a.startsWith('-'));
+
+let args: string[];
+
+if (userArgs.length === 0) {
+  args = ['src', '--quiet'];
+} else if (userProvidedPath) {
+  args = userArgs;
+} else {
+  args = [...userArgs, 'src'];
+}
+
+const result = spawn.sync(process.execPath, [eslintBin, ...args], { stdio: 'inherit' });
+
+process.exit(result.status ?? 1);

package/src/command/prettier.ts

@@ -0,0 +1,32 @@
+import spawn from 'cross-spawn';
+
+import { resolveBin } from '../utils/resolveBin';
+
+/**
+ * `scripts prettier` — `--check` over `src/**\/*.{ts,tsx,json,css,md}`.
+ *
+ * Flag-only user args (e.g. `scripts prettier --write`) keep the default
+ * glob so `--write` is enough. A path-like arg switches to fully
+ * user-controlled invocation.
+ */
+const prettierBin = resolveBin('prettier');
+
+const DEFAULT_GLOB = 'src/**/*.{ts,tsx,json,css,md}';
+
+const userArgs = process.argv.slice(2);
+
+const userProvidedPath = userArgs.some((a) => !a.startsWith('-'));
+
+let args: string[];
+
+if (userArgs.length === 0) {
+  args = ['--check', DEFAULT_GLOB];
+} else if (userProvidedPath) {
+  args = userArgs;
+} else {
+  args = [...userArgs, DEFAULT_GLOB];
+}
+
+const result = spawn.sync(process.execPath, [prettierBin, ...args], { stdio: 'inherit' });
+
+process.exit(result.status ?? 1);

package/src/command/validate.ts

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import spawn from 'cross-spawn';
+
+/**
+ * `scripts validate` — Apollion's standard pre-merge gate. Runs
+ * `check-types`, `prettier --check`, `lint` (parallel) then `test`
+ * with `--watchAll=false` (sequential). Bails on the first failure.
+ *
+ * Mirrors the Apollion ecosystem's own `scripts/validate.sh`
+ * orchestration so consumers don't have to reinvent it.
+ */
+const userArgs = process.argv.slice(2);
+
+const skip = new Set(
+  userArgs.filter((arg) => arg.startsWith('--skip=')).flatMap((arg) => arg.slice('--skip='.length).split(',')),
+);
+
+type Step = { name: string; cmd: string };
+
+const parallel: Step[] = [
+  { name: 'check-types', cmd: 'check-types' },
+  { name: 'prettier', cmd: 'prettier' },
+  { name: 'lint', cmd: 'lint' },
+].filter((s) => !skip.has(s.name));
+
+const sequential: Step[] = [{ name: 'test', cmd: 'test --watchAll=false' }].filter((s) => !skip.has(s.name));
+
+function runStep(step: Step): Promise<number> {
+  return new Promise((resolve) => {
+    console.log(chalk.cyan(`▶ ${step.name}`));
+
+    const [bin, ...rest] = step.cmd.split(' ');
+
+    const child = spawn(process.execPath, [require.resolve(`./${bin}`), ...rest], {
+      stdio: 'inherit',
+    });
+
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+(async () => {
+  const parallelResults = await Promise.all(parallel.map(runStep));
+
+  const parallelFailures = parallel.filter((_, i) => parallelResults[i] !== 0);
+
+  if (parallelFailures.length > 0) {
+    console.error(chalk.red(`✘ validate failed: ${parallelFailures.map((s) => s.name).join(', ')}`));
+
+    process.exit(1);
+  }
+
+  for (const step of sequential) {
+    const code = await runStep(step);
+
+    if (code !== 0) {
+      console.error(chalk.red(`✘ validate failed: ${step.name}`));
+
+      process.exit(code);
+    }
+  }
+
+  console.log(chalk.green('✓ validate passed'));
+
+  process.exit(0);
+})();

package/src/utils/resolveBin.ts

@@ -0,0 +1,36 @@
+import { createRequire } from 'module';
+import path from 'path';
+
+/**
+ * Resolve the absolute path to a dependency's CLI entrypoint as declared
+ * in its `package.json#bin`. Works for packages whose `exports` map
+ * blocks `require.resolve('<pkg>/bin/...')` (e.g. eslint 9+).
+ *
+ * @param pkgName - dependency name (e.g. `'eslint'`, `'prettier'`)
+ * @param binName - bin name when `package.json#bin` is an object map.
+ *   Defaults to `pkgName`.
+ * @param fromPath - directory to resolve `pkgName` from. Defaults to
+ *   this file's directory so production calls walk up from
+ *   `@apollion-dsi/scripts`'s install location.
+ */
+export function resolveBin(pkgName: string, binName: string = pkgName, fromPath: string = __dirname): string {
+  const req = createRequire(path.join(fromPath, 'noop.js'));
+
+  const pkgJsonPath = req.resolve(`${pkgName}/package.json`);
+
+  const pkgJson = req(pkgJsonPath) as { bin?: string | Record<string, string> };
+
+  const binField = pkgJson.bin;
+
+  if (!binField) {
+    throw new Error(`Package "${pkgName}" has no "bin" field in package.json`);
+  }
+
+  const relBin = typeof binField === 'string' ? binField : binField[binName];
+
+  if (!relBin) {
+    throw new Error(`Package "${pkgName}" has no bin named "${binName}"`);
+  }
+
+  return path.resolve(path.dirname(pkgJsonPath), relBin);
+}

package/template/src/App.tsx

@@ -1,5 +1,8 @@
-import { ApollionProvider, Button, Flex, GlobalStyle, Text, useNotification } from '@apollion-dsi/core';
-import React from 'react';
+import { Flex } from '@apollion-dsi/core/containers/flex';
+import { useNotification } from '@apollion-dsi/core/containers/notification';
+import { Button } from '@apollion-dsi/core/elements/button';
+import { Text } from '@apollion-dsi/core/elements/text';
+import { ApollionProvider, GlobalStyle } from '@apollion-dsi/core/themes';
 
 function App() {
   const { showNotification } = useNotification();

package/template/src/index.tsx

@@ -1,10 +1,12 @@
-import React from 'react';
-import { render } from 'react-dom';
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
 import { Root } from './App';
 
-render(
-  <React.StrictMode>
+const container = document.getElementById('root');
+if (!container) throw new Error('Root container #root not found');
+
+createRoot(container).render(
+  <StrictMode>
     <Root />
-  </React.StrictMode>,
-  document.getElementById('root'),
+  </StrictMode>,
 );

package/template/tsconfig.json

@@ -1,25 +1,4 @@
 {
-  "compilerOptions": {
-    "target": "es5",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "module": "esnext",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react"
-  },
-  "include": [
-    "src"
-  ]
-}
+  "extends": "@apollion-dsi/scripts/tsconfig.base.json",
+  "include": ["src"]
+}

package/tsconfig.base.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "es2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noEmit": true
+  }
+}

package/template/audit-ci.json

@@ -1,5 +0,0 @@
-{
-  "high": true,
-  "package-manager": "yarn",
-  "report-type": "summary"
-}