@dword-design/base 16.2.7 → 17.0.0

package/LICENSE.md

@@ -14,17 +14,17 @@ MIT License
 
 Copyright (c) <year> <copyright holders>
 
-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 
+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:
 
-The above copyright notice and this permission notice shall be included in all copies or substantial 
+The above copyright notice and this permission notice shall be included in all copies or substantial
 portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
-LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 
-EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/cli.js

@@ -5,19 +5,20 @@ import makeCli from "make-cli";
 import { Base } from "./index.js";
 import loadConfig from "./load-config/index.js";
 const base = new Base(await loadConfig());
-const testOptions = [{
-  description: "Only run tests matching this string or regexp",
-  name: "-g, --grep <grep>"
-}, {
-  description: "Update snapshots",
-  name: "-u, --update-snapshots"
-}, {
+const testHostOptions = [{
   description: "Run tests in interactive UI mode",
   name: "--ui-host <host>"
 }, {
   description: "Host to serve UI on; specifying this option opens UI in a browser tab",
   name: "--ui"
 }];
+const testOptions = [{
+  description: "Only run tests matching this string or regexp",
+  name: "-g, --grep <grep>"
+}, {
+  description: "Update snapshots",
+  name: "-u, --update-snapshots"
+}, ...(base.config.testInContainer ? [] : testHostOptions)];
 try {
   await makeCli({
     commands: {
@@ -43,15 +44,17 @@ try {
       prepare: {
         handler: () => base.prepare()
       },
+      test: {
+        arguments: "[patterns...]",
+        handler: (patterns, options) => base.test({
+          patterns,
+          ...options
+        }),
+        options: testOptions
+      },
       typecheck: {
         handler: () => base.typecheck()
       },
-      verify: {
-        handler: () => {
-          dotenv.config();
-          return base.verify();
-        }
-      },
       ...(base.config.testInContainer && {
         "test:raw": {
           arguments: "[patterns...]",
@@ -62,17 +65,20 @@ try {
           options: testOptions
         }
       }),
-      test: {
+      verify: {
         arguments: "[patterns...]",
-        handler: (patterns, options) => base.test({
-          patterns,
-          ...options
-        }),
+        handler: (patterns, options) => {
+          dotenv.config();
+          return base.verify({
+            patterns,
+            ...options
+          });
+        },
         options: testOptions
       },
       ...mapValues(base.config.commands, (command, name) => ({
         ...command,
-        handler: (...args) => base.run(name, ...args)
+        handler: (...arguments_) => base.run(name, ...arguments_)
       }))
     }
   });

package/dist/commands/check-unknown-files/index.d.ts

@@ -1 +1,3 @@
-export default function (): Promise<void>;
+import type { Base } from '@/src';
+declare const _default: (base: Base) => Promise<void>;
+export default _default;

package/dist/commands/check-unknown-files/index.js

@@ -1,8 +1,8 @@
 import { globby } from "globby";
 import ignore from "ignore";
 import UnknownFilesError from "./unknown-files-error.js";
-export default async function () {
-  const allowedMatches = [...Object.keys(this.generatedFiles), ...Object.keys({
+export default async base => {
+  const allowedMatches = [...Object.keys(base.generatedFiles), ...Object.keys({
     ".baserc.json": true,
     ".env.schema.json": true,
     ".git": true,
@@ -13,28 +13,28 @@ export default async function () {
     ".husky/post-merge": true,
     ".husky/pre-commit": true,
     ".husky/pre-push": true,
-    "CHANGELOG.md": true,
-    PRCHECKLIST: true,
     "base.config.ts": true,
+    "CHANGELOG.md": true,
     demo: true,
     doc: true,
     fixtures: true,
     patches: true,
     "pnpm-lock.yaml": true,
-    "pnpm-workspace.yaml": true
+    "pnpm-workspace.yaml": true,
+    PRCHECKLIST: true
   }), ...Object.keys({
     "**/*-snapshots/**": true,
     // For some reason without the trailing ** didn't work
     "playwright.config.ts": true
-  }), ...this.config.allowedMatches];
+  }), ...base.config.allowedMatches];
   let unknownFiles = await globby("**", {
-    cwd: this.cwd,
+    cwd: base.cwd,
     dot: true,
     gitignore: true,
     ignore: allowedMatches
   });
-  unknownFiles = unknownFiles.filter(ignore().add(this.getGitignoreConfig()).createFilter());
+  unknownFiles = unknownFiles.filter(ignore().add(base.getGitignoreConfig()).createFilter());
   if (unknownFiles.length > 0) {
     throw new UnknownFilesError(Object.fromEntries(unknownFiles.map(file => [file, true])));
   }
-}
+};

package/dist/commands/check-unknown-files/unknown-files-error.d.ts

@@ -1,3 +1,3 @@
 export default class extends Error {
-    constructor(files: any);
+    constructor(files: Record<string, true>);
 }

package/dist/commands/check-unknown-files/unknown-files-error.js

@@ -1,13 +1,12 @@
 import endent from "endent";
 import fs from "fs-extra";
-import { identity, sortBy } from "lodash-es";
 const packageConfig = fs.readJsonSync(new URL("../../../package.json", import.meta.url));
 export default class extends Error {
   constructor(files) {
     super(endent`
       There are files in this repository that are not known to ${packageConfig.name}. Let's discuss about them in a PR!
 
-      ${sortBy(Object.keys(files).map(file => `* ${file}`), identity).join("\n")}
+      ${Object.keys(files).map(file => `* ${file}`).toSorted((a, b) => a.localeCompare(b)).join("\n")}
     `);
   }
 }

package/dist/commands/command-options-input.d.ts

@@ -1,7 +1,6 @@
-import type { StdoutStderrOptionCommon } from 'execa';
-
+import type { StdoutStderrOption } from 'execa';
 export type PartialCommandOptions = {
-  log?: boolean;
-  stderr?: StdoutStderrOptionCommon<false>;
-  env?: Record<string, string>;
+    env?: Record<string, string>;
+    log?: boolean;
+    stderr?: StdoutStderrOption;
 };

package/dist/commands/commit/index.d.ts

@@ -1 +1,10 @@
-export default function (options: any): import("execa").ResultPromise<any>;
+import type { Base } from '@/src';
+import type { PartialCommandOptions } from '@/src/commands/command-options-input';
+declare const _default: (base: Base, options?: PartialCommandOptions & {
+    allowEmpty?: boolean;
+}) => import("execa").ResultPromise<{
+    cwd: any;
+    stderr: any;
+    stdout: "pipe" | "inherit";
+}>;
+export default _default;

package/dist/commands/commit/index.js

@@ -1,15 +1,14 @@
 import { execaCommand } from "execa";
-export default function (options) {
+export default (base, options = {}) => {
   options = {
+    allowEmpty: false,
     log: process.env.NODE_ENV !== "test",
     stderr: "inherit",
     ...options
   };
   return execaCommand(`git-cz${options.allowEmpty ? " --allow-empty" : ""}`, {
-    cwd: this.cwd,
-    ...(options.log && {
-      stdout: "inherit"
-    }),
-    stderr: options.stderr
+    cwd: base.cwd,
+    stderr: options.stderr,
+    stdout: options.log ? "inherit" : "pipe"
   });
-}
+};

package/dist/commands/depcheck/index.d.ts

@@ -1 +1,3 @@
-export default function (): Promise<void>;
+import type { Base } from '@/src';
+declare const _default: (base: Base) => Promise<void>;
+export default _default;

package/dist/commands/depcheck/index.js

@@ -1,37 +1,37 @@
 import depcheck from "depcheck";
 import endent from "endent";
 import { isEmpty, mapValues, omit } from "lodash-es";
-export default async function () {
-  const dependenciesTypes = Object.keys(this.packageConfig.dependencies ?? {}).filter(dependency => dependency.startsWith("@types/"));
-  const dependenciesResult = await depcheck(this.cwd, {
-    package: omit(this.packageConfig, ["devDependencies"]),
-    skipMissing: true,
-    ...this.config.depcheckConfig,
-    ignorePatterns: ["*.spec.ts", "/fixtures", "/playwright.config.ts", "package.json", "eslint.config.ts"]
+export default async base => {
+  const dependenciesTypes = Object.keys(base.packageConfig.dependencies ?? {}).filter(dependency => dependency.startsWith("@types/"));
+  const dependenciesResult = await depcheck(base.cwd, {
+    ignorePatterns: ["*.spec.ts", "/fixtures", "/playwright.config.ts", "package.json", "eslint.config.ts"],
+    package: omit(base.packageConfig, ["devDependencies"]),
+    ...base.config.depcheckConfig,
+    skipMissing: true
   });
-  const devDependenciesResult = await depcheck(this.cwd, {
-    package: omit(this.packageConfig, ["dependencies"]),
-    skipMissing: true,
-    ...this.config.depcheckConfig,
-    ignorePatterns: ["!*.spec.ts", "!/fixtures", "!/playwright.config.ts", "eslint.config.ts"]
+  const developmentDependenciesResult = await depcheck(base.cwd, {
+    ignorePatterns: ["!*.spec.ts", "!/fixtures", "!/playwright.config.ts", "eslint.config.ts"],
+    package: omit(base.packageConfig, ["dependencies"]),
+    ...base.config.depcheckConfig,
+    skipMissing: true
   });
   const result = {
     dependencies: dependenciesResult.dependencies,
-    devDependencies: devDependenciesResult.devDependencies,
+    devDependencies: developmentDependenciesResult.devDependencies,
     invalidFiles: {
       ...dependenciesResult.invalidFiles,
-      ...devDependenciesResult.invalidFiles
+      ...developmentDependenciesResult.invalidFiles
     }
   };
   const errorMessage = [...(dependenciesTypes.length > 0 ? [endent`
             Types dependencies should be in devDependencies
-            ${dependenciesTypes.map(dep => `* ${dep}`).join("\n")}
+            ${dependenciesTypes.map(dependency => `* ${dependency}`).join("\n")}
           `] : []), ...(result.dependencies.length > 0 ? [endent`
             Unused dependencies
-            ${result.dependencies.map(dep => `* ${dep}`).join("\n")}
+            ${result.dependencies.map(dependency => `* ${dependency}`).join("\n")}
           `] : []), ...(result.devDependencies.length > 0 ? [endent`
             Unused devDependencies
-            ${result.devDependencies.map(dep => `* ${dep}`).join("\n")}
+            ${result.devDependencies.map(dependency => `* ${dependency}`).join("\n")}
           `] : []), ...(isEmpty(result.invalidFiles) ? [] : [endent`
             Invalid files
             ${Object.values(mapValues(result.invalidFiles, (error, name) => `* ${name}: ${error}`)).join("\n")}
@@ -39,4 +39,4 @@ export default async function () {
   if (errorMessage) {
     throw new Error(errorMessage);
   }
-}
+};

package/dist/commands/lint/index.d.ts

@@ -1,2 +1,4 @@
+import type { Base } from '@/src';
 import type { PartialCommandOptions } from '@/src/commands/command-options-input';
-export default function (options?: PartialCommandOptions): Promise<import("execa").Result<any>>;
+declare const _default: (base: Base, options?: PartialCommandOptions) => Promise<import("execa").Result<any>>;
+export default _default;

package/dist/commands/lint/index.js

@@ -1,23 +1,22 @@
 import { execaCommand } from "execa";
 import parsePackagejsonName from "parse-packagejson-name";
-export default async function (options = {}) {
+export default async (base, options = {}) => {
   options = {
     log: process.env.NODE_ENV !== "test",
     stderr: "inherit",
     ...options
   };
-  this.lintPackagejson();
-  const packageName = parsePackagejsonName(this.packageConfig.name).fullName;
-  if (this.config.git !== void 0 && packageName !== this.config.git.project) {
-    throw new Error(`Package name '${packageName}' has to be equal to repository name '${this.config.git.project}'`);
+  base.lintPackagejson();
+  const packageName = parsePackagejsonName(base.packageConfig.name).fullName;
+  if (base.config.git !== void 0 && packageName !== base.config.git.project) {
+    throw new Error(`Package name '${packageName}' has to be equal to repository name '${base.config.git.project}'`);
   }
-  await this.config.lint.call(this, options);
-  const result = await execaCommand("eslint --fix --no-error-on-unmatched-pattern .", {
+  await base.config.lint(base, options);
+  return execaCommand("eslint --fix --no-error-on-unmatched-pattern .", {
     ...(options.log && {
       stdout: "inherit"
     }),
-    cwd: this.cwd,
+    cwd: base.cwd,
     stderr: options.stderr
   });
-  return result;
-}
+};

package/dist/commands/lint/lint-packagejson.d.ts

@@ -1 +1,3 @@
-export default function (): void;
+import type { Base } from '@/src';
+declare const _default: (base: Base) => void;
+export default _default;

package/dist/commands/lint/lint-packagejson.js

@@ -5,11 +5,11 @@ const ajv = new Ajv({
   allowUnionTypes: true
 });
 const validatePackageJson = ajv.compile(packageJsonSchema);
-export default function () {
-  if (!validatePackageJson(this.packageConfig)) {
+export default base => {
+  if (!validatePackageJson(base.packageConfig)) {
     throw new Error(endent`
       package.json invalid
       ${ajv.errorsText(validatePackageJson.errors)}
     `);
   }
-}
+};

package/dist/commands/lint/package-json-schema.js

@@ -1,5 +1,5 @@
 import packageNameRegex from "package-name-regex";
-const distPattern = /^\.\/dist\//;
+const distributionPattern = /^\.\/dist\//;
 export default {
   properties: {
     baseConfig: {
@@ -15,10 +15,10 @@ export default {
     },
     bin: {
       additionalProperties: {
-        pattern: distPattern.source,
+        pattern: distributionPattern.source,
         type: "string"
       },
-      pattern: distPattern.source,
+      pattern: distributionPattern.source,
       type: ["object", "string"]
     },
     dependencies: {

package/dist/commands/prepare/index.d.ts

@@ -1 +1,4 @@
-export default function (options: any): Promise<void>;
+import type { Base } from '@/src';
+import type { PartialCommandOptions } from '@/src/commands/command-options-input';
+declare const _default: (base: Base, options?: PartialCommandOptions) => Promise<void>;
+export default _default;

package/dist/commands/prepare/index.js

@@ -6,35 +6,35 @@ import fs from "fs-extra";
 import outputFiles from "output-files";
 const resolver = createRequire(import.meta.url);
 const commitlintPackageConfig = resolver(packageName`@commitlint/cli/package.json`);
-export default async function (options) {
+export default async (base, options = {}) => {
   options = {
     log: process.env.NODE_ENV !== "test",
     stderr: "inherit",
     ...options
   };
-  await outputFiles(this.cwd, this.generatedFiles);
-  if (await fs.exists(pathLib.join(this.cwd, ".git"))) {
+  await outputFiles(base.cwd, base.generatedFiles);
+  if (await fs.exists(pathLib.join(base.cwd, ".git"))) {
     await execaCommand("husky install", {
-      cwd: this.cwd,
+      cwd: base.cwd,
       ...(options.log && {
         stdout: "inherit"
       }),
       stderr: options.stderr
     });
     await execa("husky", ["set", ".husky/commit-msg", `npx ${Object.keys(commitlintPackageConfig.bin)[0]} --edit "$1"`], {
-      cwd: this.cwd,
+      cwd: base.cwd,
       ...(options.log && {
         stdout: "inherit"
       }),
       stderr: options.stderr
     });
     await execa("husky", ["set", ".husky/pre-commit", `npx ${packageName`lint-staged`}`], {
-      cwd: this.cwd,
+      cwd: base.cwd,
       ...(options.log && {
         stdout: "inherit"
       }),
       stderr: options.stderr
     });
   }
-  await this.config.prepare.call(this, options);
-}
+  await base.config.prepare(base, options);
+};

package/dist/commands/test/index.d.ts

@@ -1 +1,10 @@
-export default function (options: any): any;
+import type { Base } from '@/src';
+import type { PartialCommandOptions } from '@/src/commands/command-options-input';
+declare const _default: (base: Base, options?: PartialCommandOptions & {
+    grep?: string;
+    patterns?: string[];
+    ui?: boolean;
+    uiHost?: string;
+    updateSnapshots?: boolean;
+}) => any;
+export default _default;

package/dist/commands/test/index.js

@@ -1,3 +1 @@
-export default function (options) {
-  return this.config.testInContainer ? this.testDocker(options) : this.testRaw(options);
-}
+export default (base, options = {}) => base.config.testInContainer ? base.testDocker(options) : base.testRaw(options);

package/dist/commands/test-docker/index.d.ts

@@ -1 +1,12 @@
-export default function (options: any): Promise<import("execa").Result<any>>;
+import type { Base } from '@/src';
+import type { PartialCommandOptions } from '@/src/commands/command-options-input';
+declare const _default: (base: Base, optionsInput?: PartialCommandOptions & {
+    grep?: string;
+    patterns?: string[];
+    updateSnapshots?: boolean;
+}) => Promise<import("execa").Result<{
+    cwd: any;
+    stderr: any;
+    stdout: "pipe" | "inherit";
+}>>;
+export default _default;

package/dist/commands/test-docker/index.js

@@ -3,35 +3,39 @@ import { constantCase } from "change-case";
 import { execa } from "execa";
 import { findUpSync } from "find-up";
 import fs from "fs-extra";
-export default async function (options) {
-  options = {
+export default async (base, optionsInput = {}) => {
+  if (!base.packageConfig.name) {
+    throw new Error("package.json must have a name field to run tests in Docker.");
+  }
+  const options = {
+    grep: "",
     log: process.env.NODE_ENV !== "test",
     patterns: [],
     stderr: "inherit",
-    ...options
+    updateSnapshots: false,
+    ...optionsInput
   };
-  const volumeName = this.packageConfig.name.replace("@", "").replace("/", "-");
-  const envSchemaPath = findUpSync(".env.schema.json", {
-    cwd: this.cwd
+  const volumeName = base.packageConfig.name.replace("@", "").replace("/", "-");
+  const environmentSchemaPath = findUpSync(".env.schema.json", {
+    cwd: base.cwd
   });
-  const envVariableNames = Object.keys({
+  const environmentVariableNames = Object.keys({
     CI: true,
-    ...(envSchemaPath ? await fs.readJson(envSchemaPath) : {})
+    ...(environmentSchemaPath && (await fs.readJson(environmentSchemaPath)))
   }).map(name => constantCase(name));
   const userInfo = getUserInfo();
   try {
-    return await execa("docker", ["run", "--rm", ...envVariableNames.filter(name => process.env[name] !== void 0).flatMap(name => ["--env", name]), "-v", `${this.cwd}:/app`, "-v", `${volumeName}:/app/node_modules`, "dworddesign/testing:latest", "bash", "-c", ["pnpm install --frozen-lockfile", "&&", "pnpm test:raw", ...(options.updateSnapshots ? [" --update-snapshots"] : []), ...options.patterns.map(pattern => `"${pattern}"`), ...(options.grep ? [`-g "${options.grep}"`] : [])].join(" ")], {
-      cwd: this.cwd,
-      ...(options.log && {
-        stdout: "inherit"
-      }),
-      stderr: options.stderr
+    return await execa("docker", ["run", "--rm", ...environmentVariableNames.filter(name => process.env[name] !== void 0).flatMap(name => ["--env", name]), "-v", `${base.cwd}:/app`, "-v", `${volumeName}:/app/node_modules`, "dworddesign/testing:latest", "bash", "-c", ["pnpm install --frozen-lockfile", "&&", "pnpm test:raw", ...(options.updateSnapshots ? [" --update-snapshots"] : []), ...options.patterns.map(pattern => `"${pattern}"`), ...(options.grep ? [`-g "${options.grep}"`] : [])].join(" ")], {
+      cwd: base.cwd,
+      stderr: options.stderr,
+      // ...(options.log && { stdout: 'inherit' }),
+      stdout: options.log ? "inherit" : "pipe"
     });
   } finally {
     if (process.platform === "linux") {
-      await execa("docker", ["run", "--rm", "--tty", "-v", `${this.cwd}:/app`, "-v", `${volumeName}:/app/node_modules`, "dworddesign/testing:latest", "bash", "-c", `chown -R ${userInfo.uid}:${userInfo.gid} /app`], {
-        cwd: this.cwd
+      await execa("docker", ["run", "--rm", "--tty", "-v", `${base.cwd}:/app`, "-v", `${volumeName}:/app/node_modules`, "dworddesign/testing:latest", "bash", "-c", `chown -R ${userInfo.uid}:${userInfo.gid} /app`], {
+        cwd: base.cwd
       });
     }
   }
-}
+};

package/dist/commands/test-raw/index.d.ts

@@ -1 +1,17 @@
-export default function (options: any): import("execa").ResultPromise<{}>;
+import type { Base } from '@/src';
+import type { PartialCommandOptions } from '@/src/commands/command-options-input';
+declare const _default: (base: Base, optionsInput?: PartialCommandOptions & {
+    grep?: string;
+    patterns?: string[];
+    ui?: boolean;
+    uiHost?: string;
+    updateSnapshots?: boolean;
+}) => import("execa").ResultPromise<{
+    cwd: any;
+    env: {
+        NODE_ENV: string;
+    };
+    stderr: any;
+    stdout: "pipe" | "inherit";
+}>;
+export default _default;

package/dist/commands/test-raw/index.js

@@ -1,31 +1,33 @@
 import packageName from "depcheck-package-name";
 import { execa } from "execa";
 import isCI from "./is-ci.js";
-export default function (options) {
-  options = {
+export default (base, optionsInput = {}) => {
+  const options = {
+    grep: "",
     log: process.env.NODE_ENV !== "test",
     patterns: [],
     stderr: "inherit",
-    ...options
+    ui: false,
+    uiHost: null,
+    updateSnapshots: false,
+    ...optionsInput
   };
-  const runDockerTests = !isCI({
-    cwd: this.cwd
+  const isRunDockerTests = !isCI({
+    cwd: base.cwd
   }) || !["win32", "darwin"].includes(process.platform);
-  return execa(packageName`c8`, ["--exclude", "fixtures", "--exclude", "test-results", "--exclude", "playwright.config.ts", "playwright", "test", "--pass-with-no-tests", ...(runDockerTests ? [] : ["--grep-invert", "@usesdocker"]), ...(options.updateSnapshots ? ["--update-snapshots"] : []), ...(options.ui ? ["--ui"] : []), ...(options.uiHost ? ["--ui-host", options.uiHost] : []), ...(options.grep ? ["--grep", options.grep] : []), "--trace", "retain-on-failure", ...(isCI({
-    cwd: this.cwd
+  return execa(packageName`c8`, ["--exclude", "fixtures", "--exclude", "test-results", "--exclude", "playwright.config.ts", "playwright", "test", "--pass-with-no-tests", ...(isRunDockerTests ? [] : ["--grep-invert", "@usesdocker"]), ...(options.updateSnapshots ? ["--update-snapshots"] : []), ...(options.ui ? ["--ui"] : []), ...(options.uiHost ? ["--ui-host", options.uiHost] : []), ...(options.grep ? ["--grep", options.grep] : []), "--trace", "retain-on-failure", ...(isCI({
+    cwd: base.cwd
   }) ? ["--forbid-only"] : []),
   /**
    * Reporter set to dot in CI environments by default.
    * See https://github.com/microsoft/playwright/blob/42ade54975f6990c41cddc7b6e11c46a36648d0d/packages/playwright/src/common/config.ts#L301.
    */
   "--reporter", "list", ...options.patterns], {
-    cwd: this.cwd,
+    cwd: base.cwd,
     env: {
       NODE_ENV: "test"
     },
-    ...(options.log && {
-      stdout: "inherit"
-    }),
-    stderr: options.stderr
+    stderr: options.stderr,
+    stdout: options.log ? "inherit" : "pipe"
   });
-}
+};

package/dist/commands/typecheck/index.d.ts

@@ -1,2 +1,4 @@
+import type { Base } from '@/src';
 import type { PartialCommandOptions } from '@/src/commands/command-options-input';
-export default function (options?: PartialCommandOptions): Promise<import("execa").Result<any> | undefined>;
+declare const _default: (base: Base, options?: PartialCommandOptions) => Promise<import("execa").Result<any> | undefined>;
+export default _default;