@w5s/dev 3.2.2 → 3.3.0

package/src/block.ts

@@ -1,153 +0,0 @@
-import { type FileOptions, file, fileSync } from './file.js';
-
-export interface BlockOptions {
-  /**
-   * The marker builder function that will take either `markerBegin` or `markerEnd`
-   *
-   * @default '# ${mark} MANAGED BLOCK'
-   */
-  marker?: (mark: 'Begin' | 'End') => string;
-
-  /**
-   * File path
-   */
-  path: string;
-
-  /**
-   * Block content to insert
-   */
-  block: string;
-
-  /**
-   * Insert position
-   */
-  insertPosition?: ['before', 'BeginningOfFile' | RegExp] | ['after', 'EndOfFile' | RegExp];
-
-  /**
-   * Block target state
-   */
-  state?: 'present' | 'absent';
-}
-
-const EOF = 'EndOfFile';
-const BOF = 'BeginningOfFile';
-const insertAt = (str: string, index: number, toInsert: string) => str.slice(0, index) + toInsert + str.slice(index);
-const matchLast = (string: string, regexp: RegExp) => {
-  const matcher = new RegExp(regexp.source, `${regexp.flags}g`);
-  let firstIndex = -1;
-  let lastIndex = -1;
-  let matches;
-
-  while (true) {
-    matches = matcher.exec(string);
-    if (matches == null) {
-      break;
-    }
-    firstIndex = matches.index;
-    lastIndex = matcher.lastIndex;
-  }
-  return { firstIndex, lastIndex };
-};
-
-function toFileOptions(options: BlockOptions): FileOptions {
-  const {
-    marker = (mark) => `# ${mark.toUpperCase()} MANAGED BLOCK`,
-    path,
-    block: blockName,
-    insertPosition = ['after', EOF],
-    state = 'present',
-  } = options;
-
-  const EOL = '\n';
-  const beginBlock = marker('Begin');
-  const endBlock = marker('End');
-
-  /**
-   * @param content
-   */
-  function findBlock(content: string) {
-    const startIndex = content.indexOf(beginBlock);
-    const endIndex = content.indexOf(endBlock) + endBlock.length;
-
-    return {
-      endIndex,
-      exists: startIndex !== -1 && endIndex >= 0,
-      startIndex,
-    };
-  }
-
-  function apply(fullContent: string, blockContent: string) {
-    const found = findBlock(fullContent);
-    const remove = state === 'absent';
-    const replaceBlock = remove ? '' : beginBlock + EOL + blockContent + EOL + endBlock;
-    const [positionDirection, positionAnchor] = insertPosition;
-
-    if (found.exists) {
-      return fullContent.slice(0, found.startIndex) + replaceBlock + fullContent.slice(found.endIndex);
-    }
-    if (remove) {
-      return fullContent;
-    }
-    switch (positionDirection) {
-      case 'before': {
-        if (positionAnchor !== BOF) {
-          const { firstIndex } = matchLast(fullContent, positionAnchor);
-          if (firstIndex >= 0) {
-            return insertAt(fullContent, firstIndex, replaceBlock + EOL);
-          }
-        }
-
-        // Beginning of file
-        return replaceBlock + EOL + fullContent;
-      }
-      case 'after': {
-        // insert
-        if (positionAnchor !== EOF) {
-          const { lastIndex } = matchLast(fullContent, positionAnchor);
-          if (lastIndex >= 0) {
-            return insertAt(fullContent, lastIndex, EOL + replaceBlock);
-          }
-        }
-
-        // end of file
-        return fullContent + EOL + replaceBlock;
-      }
-
-      default: {
-        throw new Error(`Unsupported position ${String(positionDirection)}`);
-      }
-    }
-  }
-
-  return {
-    path,
-    state: 'present',
-    update: (sourceContent) => apply(sourceContent, blockName),
-  };
-}
-
-/**
- * Replace asynchronously a block in file that follows pattern :
- *
- * marker(markerBegin)
- * ...
- * marker(markerEnd)
- *
- * @param options
- */
-export function block(options: BlockOptions) {
-  return file(toFileOptions(options));
-}
-
-/**
- * Replace synchronously a block in file that follows pattern :
- *
- * marker(markerBegin)
- * ...
- * marker(markerEnd)
- *
- * @param options
- */
-export function blockSync(options: BlockOptions) {
-  return fileSync(toFileOptions(options));
-}

package/src/directory.ts

@@ -1,73 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from 'node:fs';
-import { access, constants, mkdir, rm } from 'node:fs/promises';
-
-async function exists(path: string) {
-  try {
-    await access(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export interface DirectoryOptions {
-  /**
-   * Directory path
-   */
-  readonly path: string;
-
-  /**
-   * Directory target state
-   */
-  readonly state: 'present' | 'absent';
-}
-
-/**
- * Ensure directory is present/absent
- *
- * @example
- * ```ts
- * await directory({
- *   path: 'foo/bar',
- *   state: 'present',
- * })
- * ```
- *
- * @param options
- */
-export async function directory(options: DirectoryOptions): Promise<void> {
-  const { path, state } = options;
-  const isPresent = await exists(path);
-  if (state === 'present') {
-    if (!isPresent) {
-      await mkdir(path, { recursive: true });
-    }
-  } else if (isPresent) {
-    await rm(path, { recursive: true });
-  }
-}
-
-/**
- * Ensure directory is present/absent
- *
- * @example
- * ```ts
- * await directorySync({
- *   path: 'foo/bar',
- *   state: 'present',
- * })
- * ```
- *
- * @param options
- */
-export function directorySync(options: DirectoryOptions): void {
-  const { path, state } = options;
-  const isPresent = existsSync(path);
-  if (state === 'present') {
-    if (!isPresent) {
-      mkdirSync(path, { recursive: true });
-    }
-  } else if (isPresent) {
-    rmSync(path, { recursive: true });
-  }
-}

package/src/exec.ts

@@ -1,73 +0,0 @@
-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
- * @param options
- * @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
- * @param options
- */
-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) => {
-        stdout += data.toString(encoding);
-      });
-    }
-    if (child.stderr != null) {
-      child.stderr.on('data', (data) => {
-        stderr += data.toString(encoding);
-      });
-    }
-    // Handle process exit
-    child.on('close', (_code) => {
-      resolve({ stdout, stderr });
-    });
-
-    // Handle errors
-    child.on('error', reject);
-  });
-}

package/src/file.ts

@@ -1,99 +0,0 @@
-import { readFile, rm, writeFile, access } from 'node:fs/promises';
-import { accessSync, constants, readFileSync, rmSync, writeFileSync } from 'node:fs';
-
-async function exists(path: string) {
-  try {
-    await access(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function existsSync(path: string) {
-  try {
-    accessSync(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export interface FileOptions {
-  /**
-   * File path
-   */
-  readonly path: string;
-
-  /**
-   * File target state
-   */
-  readonly state: 'present' | 'absent';
-
-  /**
-   * File content mapping function
-   *
-   */
-  readonly update?: ((content: string) => string | undefined) | undefined;
-
-  /**
-   * File encoding
-   */
-  readonly encoding?: BufferEncoding;
-}
-
-/**
- * Ensure file is present/absent with content initialized or modified with `update
- *
- * @example
- * ```ts
- * await file({
- *   path: 'foo/bar',
- *   state: 'present',
- *   update: (content) => content + '_test', // This will append '_test' after current content
- * })
- * ```
- *
- * @param options
- */
-export async function file(options: FileOptions): Promise<void> {
-  const { path, state, update, encoding = 'utf8' } = options;
-  if (state === 'present') {
-    const isPresent = await exists(path);
-    const previousContent = isPresent ? await readFile(path, encoding) : '';
-    const newContent = update == null ? '' : update(previousContent);
-    if (newContent != null) {
-      await writeFile(path, newContent, encoding);
-    }
-  } else {
-    await rm(path, { force: true });
-  }
-}
-
-/**
- * Ensure file is present/absent with content initialized or modified with `update
- *
- * @example
- * ```ts
- * fileSync({
- *   path: 'foo/bar',
- *   state: 'present',
- *   update: (content) => content + '_test', // This will append '_test' after current content
- * })
- * ```
- *
- * @param options
- */
-export function fileSync(options: FileOptions): void {
-  const { path, state, update, encoding = 'utf8' } = options;
-  if (state === 'present') {
-    const isPresent = existsSync(path);
-    const previousContent = isPresent ? readFileSync(path, encoding) : '';
-    const newContent = update == null ? '' : update(previousContent);
-    if (newContent != null) {
-      writeFileSync(path, newContent, encoding);
-    }
-  } else {
-    rmSync(path, { force: true });
-  }
-}

package/src/json.ts

@@ -1,58 +0,0 @@
-import { type FileOptions, file, fileSync } from './file.js';
-
-export type JSONValue = null | number | string | boolean | JSONValue[] | { [key: string]: JSONValue };
-
-export interface JSONOption<V = JSONValue> {
-  /**
-   * File path
-   */
-  readonly path: string;
-
-  /**
-   * File target state
-   */
-  readonly state: 'present' | 'absent';
-
-  /**
-   * File content mapping function
-   */
-  readonly update?: ((content: V | undefined) => V | undefined) | undefined;
-
-  /**
-   * File encoding
-   */
-  readonly encoding?: BufferEncoding;
-}
-
-function toFileOption<Value>({ update, ...otherOptions }: JSONOption<Value>): FileOptions {
-  return {
-    ...otherOptions,
-
-    update:
-      update == null
-        ? update
-        : (content) => {
-            const jsonValue = content === '' ? undefined : (JSON.parse(content) as Value);
-
-            return JSON.stringify(update(jsonValue));
-          },
-  };
-}
-
-/**
- * Ensure file is present/absent asynchronously with content value initialized or modified with `update`
- *
- * @param options
- */
-export async function json<Value>(options: JSONOption<Value>): Promise<void> {
-  return file(toFileOption(options));
-}
-
-/**
- * Ensure file is present/absent synchronously with content value initialized or modified with `update`
- *
- * @param options
- */
-export function jsonSync<Value>(options: JSONOption<Value>): void {
-  return fileSync(toFileOption(options));
-}

package/src/yarnConfig.ts

@@ -1,61 +0,0 @@
-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
-   *
-   */
-  readonly update?: ((content: string) => string | undefined) | undefined;
-}
-
-/**
- * Synchronous version of {@link yarnConfig}
- *
- * @param options
- * @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
- *
- * @param options
- * @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

@@ -1,56 +0,0 @@
-import { exec, execSync } from './exec.js';
-
-export type YarnVersionKind = 'berry' | 'classic';
-
-export interface YarnVersionOptions {
-  /**
-   * Option target state
-   */
-  readonly state: 'present' | 'absent';
-
-  /**
-   * Version mapping function
-   *
-   */
-  readonly update?: (() => YarnVersionKind | undefined) | undefined;
-}
-
-/**
- * Synchronous version of {@link yarnVersion}
- *
- * @param options
- * @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
- *
- * @param options
- * @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');
-  }
-}