@w5s/dev 2.3.0 → 2.5.0

package/src/exec.ts

@@ -0,0 +1,73 @@
+import { spawn, spawnSync } from 'node:child_process';
+
+export interface ExecOptions {
+  /**
+   * Current working directory
+   */
+  cwd?: string;
+  /**
+   * Stdio options
+   */
+  stdio?: 'inherit' | 'pipe' | 'ignore';
+}
+
+/**
+ * Runs a command in a shell and returns a promise that resolves with an object
+ * containing the stdout and stderr strings.
+ *
+ * @param command - The command to run
+ * @param args - The arguments to pass to the command
+ * @returns A promise that resolves with an object like `{ stdout: string, stderr: string }`
+ */
+export function execSync(
+  command: string,
+  args: ReadonlyArray<string>,
+  options?: ExecOptions,
+): { stdout: string; stderr: string } {
+  const result = spawnSync(command, args, { ...options });
+  const encoding = 'utf8';
+
+  return { stdout: result.stdout.toString(encoding), stderr: result.stderr.toString(encoding) };
+}
+
+/**
+ * Runs a command in a shell and returns a promise that resolves with an object
+ * containing the stdout and stderr strings.
+ *
+ * @param command - The command to run
+ * @param args - The arguments to pass to the command
+ * @returns A promise that resolves with an object containing the stdout and stderr strings
+ */
+export async function exec(
+  command: string,
+  args: ReadonlyArray<string>,
+  options?: ExecOptions,
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const encoding = 'utf8';
+    const child = spawn(command, args, { ...options });
+    let stdout = '';
+    let stderr = '';
+
+    // Capture the stdout and stderr streams
+    if (child.stdout != null) {
+      child.stdout.on('data', (data) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        stdout += data.toString(encoding);
+      });
+    }
+    if (child.stderr != null) {
+      child.stderr.on('data', (data) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        stderr += data.toString(encoding);
+      });
+    }
+    // Handle process exit
+    child.on('close', (_code) => {
+      resolve({ stdout, stderr });
+    });
+
+    // Handle errors
+    child.on('error', reject);
+  });
+}

package/src/index.ts

@@ -1,7 +1,11 @@
 export * from './directory.js';
-export * from './eslint.js';
+export * from './ESLintConfig.js';
 export * from './block.js';
 export * from './file.js';
+export * from './interopDefault.js';
+export * from './LanguageId.js';
 export * from './json.js';
-export * from './project.js';
-export * from './projectScript.js';
+export * from './Project.js';
+export * from './ProjectScript.js';
+export * from './yarnConfig.js';
+export * from './yarnVersion.js';

package/src/interopDefault.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolves a module or promise-like object, returning the default export if available.
+ *
+ * @example
+ * ```ts
+ * await interopDefault(import('./module'));// Can be a commonjs or esm module
+ * ```
+ *
+ * @template T - The type of the module or promise-like object.
+ * @param {T | PromiseLike<T>} m - The module or promise-like object to resolve.
+ * @returns {Promise<T extends { default: infer U } ? U : T>} A promise resolving to the default export if present, otherwise the module itself.
+ */
+
+export async function interopDefault<T>(m: T | PromiseLike<T>): Promise<T extends { default: infer U } ? U : T> {
+  const resolved = await m;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+  return (resolved as any).default ?? resolved;
+}

package/src/yarnConfig.ts

@@ -0,0 +1,60 @@
+import { exec, execSync } from './exec.js';
+
+export interface YarnConfigOptions {
+  /**
+   * Configuration key
+   */
+  readonly key: string;
+
+  /**
+   * Option target state
+   */
+  readonly state: 'present' | 'absent';
+
+  /**
+   * File content mapping function
+   *
+   * @param content
+   */
+  readonly update?: ((content: string) => string | undefined) | undefined;
+}
+
+/**
+ * Synchronous version of {@link yarnConfig}
+ *
+ * @example
+ * yarnConfigSync({
+ *   key: 'nodeLinker',
+ *   state: 'present',
+ *   update: (content) => content.replace('node-modules', 'hoisted'),
+ * })
+ */
+export function yarnConfigSync(options: YarnConfigOptions) {
+  const { key, state, update } = options;
+  if (state === 'present') {
+    const { stdout } = execSync('yarn', ['config', 'get', String(key)]);
+    execSync('yarn', ['config', 'set', String(key), `${update == null ? '' : update(stdout)}`]);
+  } else {
+    execSync('yarn', ['config', 'unset']);
+  }
+}
+
+/**
+ * Set/Unset yarn configuration value
+ *
+ * @example
+ * await yarnConfig({
+ *   key: 'nodeLinker',
+ *   state: 'present',
+ *   update: (content) => content.replace('node-modules', 'hoisted'),
+ * })
+ */
+export async function yarnConfig(options: YarnConfigOptions): Promise<void> {
+  const { key, state, update } = options;
+  if (state === 'present') {
+    const { stdout } = await exec('yarn', ['config', 'get', String(key)]);
+    await exec('yarn', ['config', 'set', String(key), `${update == null ? '' : update(stdout)}`]);
+  } else {
+    await exec('yarn', ['config', 'unset']);
+  }
+}

package/src/yarnVersion.ts

@@ -0,0 +1,55 @@
+import { exec, execSync } from './exec.js';
+
+export type YarnVersionKind = 'berry' | 'classic';
+
+export interface YarnVersionOptions {
+  /**
+   * Option target state
+   */
+  readonly state: 'present' | 'absent';
+
+  /**
+   * Version mapping function
+   *
+   * @param content
+   */
+  readonly update?: (() => YarnVersionKind | undefined) | undefined;
+}
+
+/**
+ * Synchronous version of {@link yarnVersion}
+ *
+ * @example
+ * yarnVersionSync({
+ *   state: 'present',
+ *   update: () => 'berry', // or 'classic'
+ * })
+ */
+export function yarnVersionSync(options: YarnVersionOptions) {
+  const { state, update } = options;
+  if (state === 'present') {
+    execSync('yarn', ['set', 'version', `${update == null ? 'berry' : update()}`]);
+  } else {
+    // TODO: remove yarn.lock
+    throw new Error('Not implemented');
+  }
+}
+
+/**
+ * Set/Unset yarn configuration value
+ *
+ * @example
+ * await yarnVersion({
+ *   state: 'present',
+ *   update: () => 'berry', // or 'classic'
+ * })
+ */
+export async function yarnVersion(options: YarnVersionOptions): Promise<void> {
+  const { state, update } = options;
+  if (state === 'present') {
+    await exec('yarn', ['set', 'version', `${update == null ? 'berry' : update()}`]);
+  } else {
+    // TODO: remove yarn.lock
+    throw new Error('Not implemented');
+  }
+}