@w5s/dev 2.2.7 → 2.2.11

package/dist/index.d.ts

@@ -1,8 +1,299 @@
-export * from './directory.js';
-export * from './eslint.js';
-export * from './block.js';
-export * from './file.js';
-export * from './json.js';
-export * from './project.js';
-export * from './projectScript.js';
-//# sourceMappingURL=index.d.ts.map
+import { ESLint, Linter } from 'eslint';
+
+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
+ */
+declare function directory(options: DirectoryOptions): Promise<void>;
+/**
+ * Ensure directory is present/absent
+ *
+ * @example
+ * ```ts
+ * await directorySync({
+ *   path: 'foo/bar',
+ *   state: 'present',
+ * })
+ * ```
+ *
+ * @param options
+ */
+declare function directorySync(options: DirectoryOptions): void;
+
+declare namespace ESLintConfig {
+    /**
+     *
+     * @param configs
+     */
+    function concat(...configs: ESLint.ConfigData[]): ESLint.ConfigData;
+    /**
+     * Always return 'off'. `_status` is the previous rule value.
+     *
+     * @param _status
+     */
+    function fixme(_status: Linter.RuleLevel | [Linter.RuleLevel, ...any[]] | undefined): "off";
+}
+
+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';
+}
+/**
+ * Replace asynchronously a block in file that follows pattern :
+ *
+ * marker(markerBegin)
+ * ...
+ * marker(markerEnd)
+ *
+ * @param options
+ */
+declare function block(options: BlockOptions): Promise<void>;
+/**
+ * Replace synchronously a block in file that follows pattern :
+ *
+ * marker(markerBegin)
+ * ...
+ * marker(markerEnd)
+ *
+ * @param options
+ */
+declare function blockSync(options: BlockOptions): void;
+
+interface FileOptions {
+    /**
+     * File path
+     */
+    readonly path: string;
+    /**
+     * File target state
+     */
+    readonly state: 'present' | 'absent';
+    /**
+     * File content mapping function
+     *
+     * @param content
+     */
+    readonly update?: (content: string) => string | 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
+ */
+declare function file(options: FileOptions): Promise<void>;
+/**
+ * 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
+ */
+declare function fileSync(options: FileOptions): void;
+
+type JSONValue = null | number | string | boolean | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+interface JSONOption<V = JSONValue> {
+    /**
+     * File path
+     */
+    readonly path: string;
+    /**
+     * File target state
+     */
+    readonly state: 'present' | 'absent';
+    /**
+     * File content mapping function
+     *
+     * @param content
+     */
+    readonly update?: (content: V | undefined) => V | undefined;
+    /**
+     * File encoding
+     */
+    readonly encoding?: BufferEncoding;
+}
+/**
+ * Ensure file is present/absent asynchronously with content value initialized or modified with `update`
+ *
+ * @param options
+ */
+declare function json<Value>(options: JSONOption<Value>): Promise<void>;
+/**
+ * Ensure file is present/absent synchronously with content value initialized or modified with `update`
+ *
+ * @param options
+ */
+declare function jsonSync<Value>(options: JSONOption<Value>): void;
+
+declare namespace Project {
+    /**
+     * A type of a file extension
+     */
+    type Extension = `.${string}`;
+    /**
+     * Object hash of all well-known file extension category to file extensions mapping
+     */
+    interface ExtensionRegistry {
+        graphql: readonly Extension[];
+        jpeg: readonly Extension[];
+        javascript: readonly Extension[];
+        javascriptreact: readonly Extension[];
+        typescript: readonly Extension[];
+        typescriptreact: readonly Extension[];
+        yaml: readonly Extension[];
+    }
+    /**
+     * A list of "vscode-like" language identifiers (i.e. "javascript", "javascriptreact")
+     */
+    type LanguageId = keyof ExtensionRegistry;
+    /**
+     * Supported ECMA version
+     *
+     * @example
+     * ```ts
+     * Project.ecmaVersion() // 2022
+     * ```
+     */
+    function ecmaVersion(): 2022;
+    /**
+     * Return a list of extensions
+     *
+     * @example
+     * ```ts
+     * Project.queryExtensions(['javascript']); // ['.js', '.cjs', ...]
+     * Project.queryExtensions(['typescript', 'typescriptreact']); // ['.ts', '.mts', ..., '.tsx']
+     * ```
+     *
+     * @param languages
+     */
+    function queryExtensions(languages: LanguageId[]): readonly Extension[];
+    /**
+     * Supported file extensions
+     *
+     * @example
+     * ```ts
+     * Project.sourceExtensions() // ['.ts', '.js', ...]
+     * ```
+     */
+    function sourceExtensions(): readonly `.${string}`[];
+    /**
+     * Resource file extensions
+     *
+     * @example
+     * ```ts
+     * Project.resourceExtensions() // ['.css', '.sass', ...]
+     * ```
+     */
+    function resourceExtensions(): readonly `.${string}`[];
+    /**
+     * Files and folders to always ignore
+     *
+     * @example
+     * ```ts
+     * IGNORED // ['node_modules/', 'build/', ...]
+     * ```
+     */
+    function ignored(): readonly string[];
+    /**
+     * Return a RegExp that will match any list of extensions
+     *
+     * @example
+     * ```ts
+     * Project.extensionsToMatcher(['.js', '.ts']) // RegExp = /(\.js|\.ts)$/
+     * ```
+     */
+    function extensionsToMatcher(extensions: readonly Extension[]): RegExp;
+    /**
+     * Return a glob matcher that will match any list of extensions
+     *
+     * @example
+     * ```ts
+     * Project.extensionsToGlob(['.js', '.ts']) // '*.+(js|ts)'
+     * ```
+     */
+    function extensionsToGlob(extensions: readonly Extension[]): string;
+}
+
+/**
+ * Project common scripts
+ */
+declare const ProjectScript: {
+    readonly Build: "build";
+    readonly Clean: "clean";
+    readonly CodeAnalysis: "code-analysis";
+    readonly Coverage: "coverage";
+    readonly Develop: "develop";
+    readonly Docs: "docs";
+    readonly Format: "format";
+    readonly Install: "install";
+    readonly Lint: "lint";
+    readonly Prepare: "prepare";
+    readonly Release: "release";
+    readonly Rescue: "rescue";
+    readonly Spellcheck: "spellcheck";
+    readonly Test: "test";
+    readonly Validate: "validate";
+};
+type ProjectScript = (typeof ProjectScript)[keyof typeof ProjectScript];
+
+export { type BlockOptions, type DirectoryOptions, ESLintConfig, type FileOptions, type JSONOption, type JSONValue, Project, ProjectScript, block, blockSync, directory, directorySync, file, fileSync, json, jsonSync };

package/dist/index.js

@@ -1,24 +1,322 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync, constants as constants$1, accessSync } from 'node:fs';
+import { mkdir, rm, readFile, writeFile, access, constants } from 'node:fs/promises';
+
+// src/directory.ts
+async function exists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function directory(options) {
+  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 });
+  }
+}
+function directorySync(options) {
+  const { path, state } = options;
+  const isPresent = existsSync(path);
+  if (state === "present") {
+    if (!isPresent) {
+      mkdirSync(path, { recursive: true });
+    }
+  } else if (isPresent) {
+    rmSync(path, { recursive: true });
+  }
+}
+
+// src/eslint.ts
+function toArray(value) {
+  if (value == null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return [value];
+}
+function concatArray(left, right) {
+  return toArray(left).concat(toArray(right));
+}
+var ESLintConfig;
+((ESLintConfig2) => {
+  function concat(...configs) {
+    return configs.reduce(
+      (returnValue, config) => ({
+        ...returnValue,
+        ...config,
+        env: { ...returnValue.env, ...config.env },
+        extends: concatArray(returnValue.extends, config.extends),
+        globals: { ...returnValue.globals, ...config.globals },
+        overrides: concatArray(returnValue.overrides, config.overrides),
+        parserOptions: { ...returnValue.parserOptions, ...config.parserOptions },
+        plugins: concatArray(returnValue.plugins, config.plugins),
+        rules: { ...returnValue.rules, ...config.rules },
+        settings: { ...returnValue.settings, ...config.settings }
+      }),
+      {
+        env: {},
+        extends: [],
+        globals: {},
+        overrides: [],
+        parserOptions: {},
+        plugins: [],
+        rules: {},
+        settings: {}
+      }
+    );
+  }
+  ESLintConfig2.concat = concat;
+  function fixme(_status) {
+    return "off";
+  }
+  ESLintConfig2.fixme = fixme;
+})(ESLintConfig || (ESLintConfig = {}));
+async function exists2(path) {
+  try {
+    await access(path, constants$1.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSync2(path) {
+  try {
+    accessSync(path, constants$1.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function file(options) {
+  const { path, state, update, encoding = "utf8" } = options;
+  if (state === "present") {
+    const isPresent = await exists2(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 });
+  }
+}
+function fileSync(options) {
+  const { path, state, update, encoding = "utf8" } = options;
+  if (state === "present") {
+    const isPresent = existsSync2(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 });
+  }
+}
+
+// src/block.ts
+var EOF = "EndOfFile";
+var BOF = "BeginningOfFile";
+var insertAt = (str, index, toInsert) => str.slice(0, index) + toInsert + str.slice(index);
+var matchLast = (string, 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) {
+  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");
+  function findBlock(content) {
+    const startIndex = content.indexOf(beginBlock);
+    const endIndex = content.indexOf(endBlock) + endBlock.length;
+    return {
+      endIndex,
+      exists: startIndex >= 0 && endIndex >= 0,
+      startIndex
+    };
+  }
+  function apply(fullContent, blockContent) {
+    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);
+          }
+        }
+        return replaceBlock + EOL + fullContent;
+      }
+      case "after": {
+        if (positionAnchor !== EOF) {
+          const { lastIndex } = matchLast(fullContent, positionAnchor);
+          if (lastIndex >= 0) {
+            return insertAt(fullContent, lastIndex, EOL + replaceBlock);
+          }
+        }
+        return fullContent + EOL + replaceBlock;
+      }
+      default: {
+        throw new Error(`Unsupported position ${String(positionDirection)}`);
+      }
+    }
+  }
+  return {
+    path,
+    state: "present",
+    update: (sourceContent) => apply(sourceContent, blockName)
+  };
+}
+function block(options) {
+  return file(toFileOptions(options));
+}
+function blockSync(options) {
+  return fileSync(toFileOptions(options));
+}
+
+// src/json.ts
+function toFileOption({ update, ...otherOptions }) {
+  return {
+    ...otherOptions,
+    update: update == null ? update : (content) => {
+      const jsonValue = content === "" ? void 0 : JSON.parse(content);
+      return JSON.stringify(update(jsonValue));
+    }
+  };
+}
+async function json(options) {
+  return file(toFileOption(options));
+}
+function jsonSync(options) {
+  return fileSync(toFileOption(options));
+}
+
+// src/project.ts
+function escapeRegExp(value) {
+  return value.replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+}
+var Project;
+((Project2) => {
+  function ecmaVersion() {
+    return 2022;
+  }
+  Project2.ecmaVersion = ecmaVersion;
+  const registry = {
+    graphql: [".gql", ".graphql"],
+    jpeg: [".jpg", ".jpeg"],
+    javascript: [".js", ".cjs", ".mjs"],
+    javascriptreact: [".jsx"],
+    typescript: [".ts", ".cts", ".mts"],
+    typescriptreact: [".tsx"],
+    yaml: [".yaml", ".yml"]
+  };
+  function queryExtensions(languages) {
+    return languages.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      (previousValue, currentValue) => previousValue.concat(registry[currentValue] ?? []),
+      []
+    ).sort();
+  }
+  Project2.queryExtensions = queryExtensions;
+  function sourceExtensions() {
+    return queryExtensions(["javascript", "javascriptreact", "typescript", "typescriptreact"]);
+  }
+  Project2.sourceExtensions = sourceExtensions;
+  const RESOURCE_EXTENSIONS = Object.freeze([
+    ".css",
+    ".sass",
+    ".scss",
+    ".less",
+    ".gif",
+    ".png",
+    ".svg",
+    ...queryExtensions(["graphql", "jpeg", "yaml"])
+  ]);
+  function resourceExtensions() {
+    return RESOURCE_EXTENSIONS;
+  }
+  Project2.resourceExtensions = resourceExtensions;
+  const IGNORED = Object.freeze([
+    "node_modules/",
+    "build/",
+    "cjs/",
+    "coverage/",
+    "dist/",
+    "dts/",
+    "esm/",
+    "lib/",
+    "mjs/",
+    "umd/"
+  ]);
+  function ignored() {
+    return IGNORED;
+  }
+  Project2.ignored = ignored;
+  function extensionsToMatcher(extensions) {
+    return new RegExp(`(${extensions.map(escapeRegExp).join("|")})$`);
+  }
+  Project2.extensionsToMatcher = extensionsToMatcher;
+  function extensionsToGlob(extensions) {
+    return `*.+(${extensions.map((_) => _.replace(/^\./, "")).join("|")})`;
+  }
+  Project2.extensionsToGlob = extensionsToGlob;
+})(Project || (Project = {}));
+
+// src/projectScript.ts
+var ProjectScript = {
+  Build: "build",
+  Clean: "clean",
+  CodeAnalysis: "code-analysis",
+  Coverage: "coverage",
+  Develop: "develop",
+  Docs: "docs",
+  Format: "format",
+  Install: "install",
+  Lint: "lint",
+  Prepare: "prepare",
+  Release: "release",
+  Rescue: "rescue",
+  Spellcheck: "spellcheck",
+  Test: "test",
+  Validate: "validate"
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./directory.js"), exports);
-__exportStar(require("./eslint.js"), exports);
-__exportStar(require("./block.js"), exports);
-__exportStar(require("./file.js"), exports);
-__exportStar(require("./json.js"), exports);
-__exportStar(require("./project.js"), exports);
-__exportStar(require("./projectScript.js"), exports);
+
+export { ESLintConfig, Project, ProjectScript, block, blockSync, directory, directorySync, file, fileSync, json, jsonSync };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map