@w5s/configurator-core 1.0.0-alpha.8 → 1.0.0-alpha.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@w5s/configurator-core",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-alpha.9",
   "description": "Core library for @w5s/configurator-core",
   "keywords": [
     "config",
@@ -36,7 +36,9 @@
   "scripts": {
     "postpack": "clean-package restore"
   },
-  "dependencies": {},
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
   "engines": {
     "node": ">=22.0.0"
   },
@@ -44,5 +46,5 @@
     "access": "public"
   },
   "sideEffect": false,
-  "gitHead": "fcde4af12d29afdb46ed396ef832c36a399ed057"
+  "gitHead": "e6c63e0164ce2199e59bdca360f4766b6a78584d"
 }

package/src/FileMode.ts

@@ -1,33 +1,33 @@
-export interface FilePermissionSet {
+export interface FileMode {
   /**
-   * Read permission
+   * Group permissions
    */
-  readonly read?: boolean;
+  readonly group?: FilePermissionSet;
 
   /**
-   * Write permission
+   * Other permissions
    */
-  readonly write?: boolean;
+  readonly other?: FilePermissionSet;
 
   /**
-   * Execute permission
+   * Owner permissions
    */
-  readonly execute?: boolean;
+  readonly owner?: FilePermissionSet;
 }
 
-export interface FileMode {
+export interface FilePermissionSet {
   /**
-   * Owner permissions
+   * Execute permission
    */
-  readonly owner?: FilePermissionSet;
+  readonly execute?: boolean;
 
   /**
-   * Group permissions
+   * Read permission
    */
-  readonly group?: FilePermissionSet;
+  readonly read?: boolean;
 
   /**
-   * Other permissions
+   * Write permission
    */
-  readonly other?: FilePermissionSet;
+  readonly write?: boolean;
 }

package/src/__exists.ts

@@ -1,5 +1,5 @@
-import { access } from 'node:fs/promises';
 import { constants } from 'node:fs';
+import { access } from 'node:fs/promises';
 
 export async function __exists(path: string) {
   try {

package/src/__toMode.ts

@@ -1,13 +1,5 @@
 import type { FileMode, FilePermissionSet } from './FileMode.js';
 
-function toModeFlag(permissionSet: FilePermissionSet | undefined, read: number, write: number, execute: number): number {
-  return (
-    (permissionSet?.read === true ? read : 0)
-    | (permissionSet?.write === true ? write : 0)
-    | (permissionSet?.execute === true ? execute : 0)
-  );
-}
-
 export function __toMode(mode: FileMode | undefined): number | undefined {
   return mode == null
     ? mode
@@ -17,3 +9,11 @@ export function __toMode(mode: FileMode | undefined): number | undefined {
         | toModeFlag(mode.other, 0o004, 0o002, 0o001)
       );
 }
+
+function toModeFlag(permissionSet: FilePermissionSet | undefined, read: number, write: number, execute: number): number {
+  return (
+    (permissionSet?.read === true ? read : 0)
+    | (permissionSet?.write === true ? write : 0)
+    | (permissionSet?.execute === true ? execute : 0)
+  );
+}

package/src/block.ts

@@ -1,32 +1,32 @@
-import { type FileOptions, file, fileSync } from './file.js';
+import { file, type FileOptions, fileSync } from './file.js';
 
 export interface BlockOptions {
   /**
-   * The marker builder function that will take either `markerBegin` or `markerEnd`
-   *
-   * @default '# ${mark} MANAGED BLOCK'
+   * Block content to insert
    */
-  marker?: (mark: 'Begin' | 'End') => string;
+  block: string;
 
   /**
-   * File path
+   * Insert position
    */
-  path: string;
+  insertPosition?: ['after', 'EndOfFile' | RegExp] | ['before', 'BeginningOfFile' | RegExp];
 
   /**
-   * Block content to insert
+   * The marker builder function that will take either `markerBegin` or `markerEnd`
+   *
+   * @default '# ${mark} MANAGED BLOCK'
    */
-  block: string;
+  marker?: (mark: 'Begin' | 'End') => string;
 
   /**
-   * Insert position
+   * File path
    */
-  insertPosition?: ['before', 'BeginningOfFile' | RegExp] | ['after', 'EndOfFile' | RegExp];
+  path: string;
 
   /**
    * Block target state
    */
-  state?: 'present' | 'absent';
+  state?: 'absent' | 'present';
 }
 
 const EOF = 'EndOfFile';
@@ -49,12 +49,38 @@ const matchLast = (string: string, regexp: RegExp) => {
   return { firstIndex, lastIndex };
 };
 
+/**
+ * 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));
+}
+
 function toFileOptions(options: BlockOptions): FileOptions {
   const {
-    marker = (mark) => `# ${mark.toUpperCase()} MANAGED BLOCK`,
-    path,
     block: blockName,
     insertPosition = ['after', EOF],
+    marker = (mark) => `# ${mark.toUpperCase()} MANAGED BLOCK`,
+    path,
     state = 'present',
   } = options;
 
@@ -89,17 +115,6 @@ function toFileOptions(options: BlockOptions): FileOptions {
       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) {
@@ -112,6 +127,17 @@ function toFileOptions(options: BlockOptions): FileOptions {
         // end of file
         return fullContent + EOL + replaceBlock;
       }
+      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;
+      }
 
       default: {
         throw new Error(`Unsupported position ${String(positionDirection)}`);
@@ -125,29 +151,3 @@ function toFileOptions(options: BlockOptions): FileOptions {
     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,25 +1,27 @@
 import { chmodSync, mkdirSync, rmSync } from 'node:fs';
 import { chmod, mkdir, rm } from 'node:fs/promises';
-import { __exists } from './__exists.js';
+
 import type { FileMode } from './FileMode.js';
-import { __toMode } from './__toMode.js';
+
+import { __exists } from './__exists.js';
 import { __existsSync } from './__existsSync.js';
+import { __toMode } from './__toMode.js';
 
 export interface DirectoryOptions {
   /**
-   * Directory path
+   * File permissions
    */
-  readonly path: string;
+  readonly mode?: FileMode;
 
   /**
-   * Directory target state
+   * Directory path
    */
-  readonly state: 'present' | 'absent';
+  readonly path: string;
 
   /**
-   * File permissions
+   * Directory target state
    */
-  readonly mode?: FileMode;
+  readonly state: 'absent' | 'present';
 }
 
 /**
@@ -41,12 +43,12 @@ export interface DirectoryOptions {
  * @param options
  */
 export async function directory(options: DirectoryOptions): Promise<void> {
-  const { path, state, mode } = options;
+  const { mode, path, state } = options;
   const isPresent = await __exists(path);
   if (state === 'present') {
     const newMode = __toMode(mode);
     if (!isPresent) {
-      await mkdir(path, { recursive: true, mode: newMode });
+      await mkdir(path, { mode: newMode, recursive: true });
     }
     if (newMode != null && isPresent) {
       await chmod(path, newMode);
@@ -75,12 +77,12 @@ export async function directory(options: DirectoryOptions): Promise<void> {
  * @param options
  */
 export function directorySync(options: DirectoryOptions): void {
-  const { path, state, mode } = options;
+  const { mode, path, state } = options;
   const isPresent = __existsSync(path);
   if (state === 'present') {
     const newMode = __toMode(mode);
     if (!isPresent) {
-      mkdirSync(path, { recursive: true, mode: newMode });
+      mkdirSync(path, { mode: newMode, recursive: true });
     }
     if (newMode != null && isPresent) {
       chmodSync(path, newMode);

package/src/exec.ts

@@ -9,27 +9,7 @@ export interface ExecOptions {
   /**
    * 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) };
+  stdio?: 'ignore' | 'inherit' | 'pipe';
 }
 
 /**
@@ -44,7 +24,7 @@ export async function exec(
   command: string,
   args: ReadonlyArray<string>,
   options?: ExecOptions,
-): Promise<{ stdout: string; stderr: string }> {
+): Promise<{ stderr: string; stdout: string }> {
   return new Promise((resolve, reject) => {
     const encoding = 'utf8';
     const child = spawn(command, args, { ...options });
@@ -64,10 +44,30 @@ export async function exec(
     }
     // Handle process exit
     child.on('close', (_code) => {
-      resolve({ stdout, stderr });
+      resolve({ stderr, stdout });
     });
 
     // Handle errors
     child.on('error', reject);
   });
 }
+
+/**
+ * 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,
+): { stderr: string; stdout: string } {
+  const result = spawnSync(command, args, { ...options });
+  const encoding = 'utf8';
+
+  return { stderr: result.stderr.toString(encoding), stdout: result.stdout.toString(encoding) };
+}

package/src/file.ts

@@ -1,36 +1,38 @@
-import { chmod, readFile, rm, writeFile } from 'node:fs/promises';
 import { chmodSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { chmod, readFile, rm, writeFile } from 'node:fs/promises';
+
+import type { FileMode } from './FileMode.js';
+
 import { __exists } from './__exists.js';
 import { __existsSync } from './__existsSync.js';
-import type { FileMode } from './FileMode.js';
 import { __toMode } from './__toMode.js';
 
 export interface FileOptions {
   /**
-   * File path
+   * File encoding
    */
-  readonly path: string;
+  readonly encoding?: BufferEncoding;
 
   /**
-   * File target state
+   * File permissions
    */
-  readonly state: 'present' | 'absent';
+  readonly mode?: FileMode;
 
   /**
-   * File content mapping function
-   *
+   * File path
    */
-  readonly update?: ((content: string) => string | undefined) | undefined;
+  readonly path: string;
 
   /**
-   * File encoding
+   * File target state
    */
-  readonly encoding?: BufferEncoding;
+  readonly state: 'absent' | 'present';
 
   /**
-   * File permissions
+   * File content mapping function
+   *
    */
-  readonly mode?: FileMode;
+  readonly update?: ((content: string) => string | undefined) | undefined;
 }
 
 /**
@@ -53,7 +55,7 @@ export interface FileOptions {
  * @param options
  */
 export async function file(options: FileOptions): Promise<void> {
-  const { path, state, update, encoding = 'utf8', mode } = options;
+  const { encoding = 'utf8', mode, path, state, update } = options;
   if (state === 'present') {
     const isPresent = await __exists(path);
     const previousContent = isPresent ? await readFile(path, encoding) : '';
@@ -90,7 +92,7 @@ export async function file(options: FileOptions): Promise<void> {
  * @param options
  */
 export function fileSync(options: FileOptions): void {
-  const { path, state, update, encoding = 'utf8', mode } = options;
+  const { encoding = 'utf8', mode, path, state, update } = options;
   if (state === 'present') {
     const isPresent = __existsSync(path);
     const previousContent = isPresent ? readFileSync(path, encoding) : '';

package/src/ignoreFile.ts

@@ -1,4 +1,4 @@
-import { type FileOptions, file, fileSync } from './file.js';
+import { file, type FileOptions, fileSync } from './file.js';
 
 export interface IgnoreFileOptions extends Omit<FileOptions, 'update'> {
   /**
@@ -8,23 +8,6 @@ export interface IgnoreFileOptions extends Omit<FileOptions, 'update'> {
   readonly update?: ((content: string[] | undefined) => string[] | undefined) | undefined;
 }
 
-function toFileOption({ update, ...otherOptions }: IgnoreFileOptions): FileOptions {
-  return {
-    ...otherOptions,
-
-    update:
-      update == null
-        ? update
-        : (content) => {
-            const eol = content.includes('\r\n') ? '\r\n' : '\n';
-            const lines = content === '' ? undefined : content.split(eol);
-            const updatedLines = update(lines);
-
-            return updatedLines == null ? undefined : updatedLines.join(eol);
-          },
-  };
-}
-
 /**
  * Ensure file is present/absent asynchronously with content initialized or modified by line.
  *
@@ -56,3 +39,20 @@ export async function ignoreFile(options: IgnoreFileOptions): Promise<void> {
 export function ignoreFileSync(options: IgnoreFileOptions): void {
   return fileSync(toFileOption(options));
 }
+
+function toFileOption({ update, ...otherOptions }: IgnoreFileOptions): FileOptions {
+  return {
+    ...otherOptions,
+
+    update:
+      update == null
+        ? update
+        : (content) => {
+            const eol = content.includes('\r\n') ? '\r\n' : '\n';
+            const lines = content === '' ? undefined : content.split(eol);
+            const updatedLines = update(lines);
+
+            return updatedLines == null ? undefined : updatedLines.join(eol);
+          },
+  };
+}

package/src/index.ts

@@ -1,8 +1,9 @@
-export * from './directory.js';
 export * from './block.js';
+export * from './directory.js';
 export * from './file.js';
 export * from './ignoreFile.js';
 export * from './json.js';
 export * from './meta.js';
+export * from './yaml.js';
 export * from './yarnConfig.js';
 export * from './yarnVersion.js';

package/src/json.ts

@@ -1,28 +1,13 @@
-import { type FileOptions, file, fileSync } from './file.js';
-
-export type JSONValue = null | number | string | boolean | JSONValue[] | { [key: string]: JSONValue };
+import { file, type FileOptions, fileSync } from './file.js';
 
 export interface JSONOption<V = JSONValue> extends Omit<FileOptions, 'update'> {
   /**
    * File content mapping function
    */
-  readonly update?: ((content: V | undefined) => V | undefined) | undefined;
+  readonly update?: ((content: undefined | V) => undefined | V) | undefined;
 }
 
-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));
-          },
-  };
-}
+export type JSONValue = boolean | JSONValue[] | null | number | string | { [key: string]: JSONValue };
 
 /**
  * Ensure file is present/absent asynchronously with content value initialized or modified with `update`
@@ -41,3 +26,18 @@ export async function json<Value>(options: JSONOption<Value>): Promise<void> {
 export function jsonSync<Value>(options: JSONOption<Value>): void {
   return fileSync(toFileOption(options));
 }
+
+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));
+          },
+  };
+}

package/src/meta.ts

@@ -1,8 +1,8 @@
 export const meta = Object.freeze({
+  // @ts-ignore - these variables are injected at build time
+  buildNumber: 1 as number, // (typeof __PACKAGE_BUILD_NUMBER__ === 'undefined' ? 0 : __PACKAGE_BUILD_NUMBER__) as number,
   // @ts-ignore - these variables are injected at build time
   name: (typeof __PACKAGE_NAME__ === 'undefined' ? '' : __PACKAGE_NAME__) as string,
   // @ts-ignore - these variables are injected at build time
   version: (typeof __PACKAGE_VERSION__ === 'undefined' ? '' : __PACKAGE_VERSION__) as string,
-  // @ts-ignore - these variables are injected at build time
-  buildNumber: 1 as number, // (typeof __PACKAGE_BUILD_NUMBER__ === 'undefined' ? 0 : __PACKAGE_BUILD_NUMBER__) as number,
 });

package/src/testing/getTempPath.ts

@@ -1,4 +1,5 @@
 import path from 'node:path';
+
 import { getRootPath } from './getRootPath.js';
 
 export function getTempPath() {

package/src/testing/getTestPath.ts

@@ -1,6 +1,7 @@
+import { mkdir, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { afterAll, beforeAll } from 'vitest';
-import { mkdir, rm } from 'node:fs/promises';
+
 import { getTempPath } from './getTempPath.js';
 
 export function getTestPath(prefix: string, remove = true) {

package/src/yaml.ts

@@ -0,0 +1,45 @@
+import YAML from 'yaml';
+
+import { file, type FileOptions, fileSync } from './file.js';
+
+export interface YAMLOption<V = YAMLValue> extends Omit<FileOptions, 'update'> {
+  /**
+   * File content mapping function
+   */
+  readonly update?: ((content: undefined | V) => undefined | V) | undefined;
+}
+
+export type YAMLValue = boolean | null | number | string | YAMLValue[] | { [key: string]: YAMLValue };
+
+/**
+ * Ensure file is present/absent asynchronously with content value initialized or modified with `update`
+ *
+ * @param options
+ */
+export async function yaml<Value>(options: YAMLOption<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 yamlSync<Value>(options: YAMLOption<Value>): void {
+  return fileSync(toFileOption(options));
+}
+
+function toFileOption<Value>({ update, ...otherOptions }: YAMLOption<Value>): FileOptions {
+  return {
+    ...otherOptions,
+
+    update:
+      update == null
+        ? update
+        : (content) => {
+            const yamlValue = content === '' ? undefined : (YAML.parse(content) as Value);
+
+            return YAML.stringify(update(yamlValue));
+          },
+  };
+}