@niche-works/dev 0.2.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niche-works/dev",
-  "version": "0.2.0",
+  "version": "0.4.1",
   "keywords": [
     "utils"
   ],
@@ -12,29 +12,36 @@
   "author": "Mitsuhiro Seino",
   "type": "module",
   "exports": {
-    ".": {
-      "import": "./index.js",
-      "reqire": "./index.cjs",
-      "type": "./index.d.ts"
-    },
-    "./*": {
-      "import": "./*/index.js",
-      "reqire": "./*/index.cjs",
-      "type": "./*/index.d.ts"
-    },
-    "./constants": {
-      "import": "./constants.js",
-      "reqire": "./constants.cjs",
-      "type": "./constants.d.ts"
-    },
-    "./*/constants": {
-      "import": "./*/constants.js",
-      "reqire": "./*/constants.cjs",
-      "type": "./*/constants.d.ts"
-    }
+    ".": "./src/index.ts",
+    "./*": "./src/*/index.ts",
+    "./*/constants": "./src/*/constants.ts"
   },
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
   "dependencies": {
     "fs-extra": "^11.3.4",
-    "remeda": "^2.33.6"
+    "remeda": "^2.33.6",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.5.0",
+    "fast-glob": "^3.3.3",
+    "prettier": "^3.8.1",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "prettier-plugin-packagejson": "^3.0.2",
+    "tsdown": "^0.21.9",
+    "tsx": "^4.21.0",
+    "type-fest": "^5.5.0",
+    "typescript": "^6.0.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc --noEmit",
+    "dev": "tsdown --watch",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json}\"",
+    "indexes": "tsx scripts/indexes.ts",
+    "lint": "tsdown --dry-run",
+    "tidy": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json}\" --config ./prettier.tidy.config.js"
   }
-}
+}

package/src/addExports/addExports.ts

@@ -0,0 +1,94 @@
+import fs from 'fs-extra';
+import { posix as path } from 'path';
+import isTargetPath from '../isTargetPath';
+import type { AddExportsOptions } from './types';
+
+/**
+ * index.tsが配置されているモジュールをpackage.jsonのexportsに追加する
+ * @param targetPath
+ * @param options
+ */
+export default function addExports(
+  targetPath: string = 'src',
+  options: AddExportsOptions = {},
+) {
+  let {
+    packageJsonPath = 'package.json',
+    include = [],
+    dist = 'dist',
+    dryRun,
+    ...rest
+  } = options;
+
+  // 処理対象を設定
+  include = [
+    // indexファイルを対象
+    {
+      valueType: 'base',
+      entryType: 'file',
+      conditions: /^index.(ts|tsx)$/i,
+    },
+    ...include,
+  ];
+
+  // exportsをpackage.jsonに追加
+  const exportsIndex = _addExports(targetPath, {
+    packageJsonPath,
+    include,
+    dist,
+    ...rest,
+  });
+
+  const packageJson = fs.readJsonSync(packageJsonPath, { encoding: 'utf8' });
+  packageJson.exports = {};
+  exportsIndex.sort((a, b) => (a.key > b.key ? 1 : -1));
+  for (const index of exportsIndex) {
+    packageJson.exports[index.key ? './' + index.key : '.'] =
+      './' + index.path + '.js';
+  }
+  if (dryRun) {
+    console.log(packageJson);
+  } else {
+    fs.writeJsonSync(packageJsonPath, packageJson, {
+      encoding: 'utf8',
+      spaces: 2,
+    });
+  }
+}
+
+function _addExports(
+  targetPath: string,
+  options: AddExportsOptions,
+  current: string = '',
+) {
+  const { include, exclude, dist = 'dist' } = options;
+
+  const stat = fs.statSync(targetPath);
+  if (!stat.isDirectory()) {
+    console.error(`"${targetPath}" is not directory.`);
+  }
+  const items = fs.readdirSync(targetPath);
+  items.sort();
+  const exportsIndex: { key: string; path: string }[] = [];
+
+  for (const item of items) {
+    const itemPath = path.join(targetPath, item);
+    const stat = fs.statSync(itemPath);
+    const { name } = path.parse(itemPath);
+
+    if (stat.isDirectory()) {
+      // ディレクトリの場合は先に子要素を処理
+      exportsIndex.push(
+        ..._addExports(itemPath, options, path.join(current, item)),
+      );
+    } else if (isTargetPath(itemPath, { include, exclude })) {
+      // exportの対象の場合
+      exportsIndex.push({
+        key: current,
+        path: path.join(dist, current, name),
+      });
+    }
+  }
+
+  return exportsIndex;
+}

package/src/addExports/index.ts

@@ -0,0 +1,2 @@
+export { default } from './addExports';
+export type * from './types';

package/src/addExports/types.ts

@@ -0,0 +1,33 @@
+import type { IsMatchingPathCondition } from '../isMatchingPath';
+
+export type AddExportsOptions = {
+  /**
+   * package.jsonのパス
+   */
+  packageJsonPath?: string;
+
+  /**
+   * ビルドしたパッケージが置かれたディレクトリの名称
+   */
+  dist?: string;
+
+  /**
+   * indexファイルを作る対象
+   * 未指定の場合は下記の条件がデフォルトで適用される
+   *
+   * - ファイル名が`_`で始まらず拡張子が`.ts`,`.tsx`,`.js`,`.jsx`のもの
+   * - ディレクトリ名が`_`で始まらないもの
+   */
+  include?: IsMatchingPathCondition[];
+
+  /**
+   * indexファイルを作る対象から除外するもの
+   */
+  exclude?: IsMatchingPathCondition[];
+
+  /**
+   * お試し
+   * ファイルの操作は行わない
+   */
+  dryRun?: boolean;
+};

package/src/addJsExtensions/addJsExtensions.ts

@@ -0,0 +1,30 @@
+import fg from 'fast-glob';
+import fs from 'fs-extra';
+
+const PATTERNS = {
+  '.js': /(?:from|import)\s*["'](\.\.?\/[^"']+)["']/g,
+  '.cjs': /require\(["'](\.\.?\/[^"']+)["']\)/g,
+};
+
+/**
+ * ローカルファイルのimportやrequireに拡張子を付与する
+ * @param dir
+ */
+export default async function addJsExtensions(dir: string) {
+  const files = await fg(`${dir}/**/*.{js,cjs}`);
+  for (const file of files) {
+    const content = await fs.readFile(file, 'utf-8');
+    const ext = file.endsWith('.cjs') ? '.cjs' : '.js';
+    const fixed = content.replace(PATTERNS[ext], (match, pos1) => {
+      if (pos1.endsWith(ext)) {
+        // 既に拡張子あり
+        return match;
+      }
+      // 拡張子を付与
+      return match.replace(pos1, `${pos1}${ext}`);
+    });
+    if (content !== fixed) {
+      await fs.writeFile(file, fixed);
+    }
+  }
+}

package/src/addJsExtensions/index.ts

@@ -0,0 +1 @@
+export { default } from './addJsExtensions';

package/src/checkExistence/checkExistence.ts

@@ -0,0 +1,16 @@
+import fs from 'fs-extra';
+
+/**
+ * ディレクトリ、ファイルの存在チェック
+ * @param targetPaths
+ * @param options
+ */
+export default function checkExistence(...targetPaths: string[]) {
+  return targetPaths.every((targetPath) => {
+    if (!fs.existsSync(targetPath)) {
+      console.error(`${targetPath}が存在しません。`);
+      return false;
+    }
+    return true;
+  });
+}

package/src/checkExistence/index.ts

@@ -0,0 +1 @@
+export { default } from './checkExistence';

package/src/createExternalOptionFunction/createExternalOptionFunction.ts

@@ -0,0 +1,43 @@
+import isMatchingPath from '../isMatchingPath';
+import type {
+  CreateExternalOptionFunctionOptions,
+  ExternalOptionFunction,
+} from './types';
+
+/**
+ * rolldownやrollupなどで内部モジュールのimport以外をexternalとして扱うための関数を作る関数
+ * @param options
+ */
+export default function createExternalOptionFunction(
+  options: CreateExternalOptionFunctionOptions = {},
+): ExternalOptionFunction {
+  const { isExternal, isInternal } = options;
+  return (
+    source: string,
+    _importer: string | undefined,
+    isResolved: boolean,
+  ) => {
+    const isMatchingPathOptions = {
+      conditionOptions: {
+        source,
+        importer: _importer,
+        isResolved,
+      },
+    };
+    if (isMatchingPath(source, isExternal, isMatchingPathOptions)) {
+      // 外部モジュール扱い
+      return true;
+    } else if (isMatchingPath(source, isInternal, isMatchingPathOptions)) {
+      // 内部モジュール扱い
+      return;
+    } else if (!isResolved) {
+      // 相対パスでもなく、srcディレクトリ配下でもないものは外部モジュール扱い
+      return (
+        !source.startsWith('.') &&
+        !source.startsWith('/') &&
+        !source.startsWith('src/')
+      );
+    }
+    return;
+  };
+}

package/src/createExternalOptionFunction/index.ts

@@ -0,0 +1 @@
+export { default } from './createExternalOptionFunction';

package/src/createExternalOptionFunction/types.ts

@@ -0,0 +1,34 @@
+import type { IsMatchingPathCondition } from '../isMatchingPath';
+
+/**
+ * オプション
+ */
+export type CreateExternalOptionFunctionOptions = {
+  /**
+   * 外部モジュールとする条件
+   */
+  isExternal?: IsMatchingPathCondition<ConditionOptions>[];
+
+  /**
+   * 内部モジュールとする条件
+   */
+  isInternal?: IsMatchingPathCondition<ConditionOptions>[];
+};
+
+/**
+ * rolldownやrollupのexternalオプションに設定可能な関数
+ */
+export type ExternalOptionFunction = (
+  source: string,
+  importer: string | undefined,
+  isResolved: boolean,
+) => boolean | null | undefined | void;
+
+/**
+ * include,excludeが関数だった場合のオプション
+ */
+export type ConditionOptions = {
+  source: string;
+  importer: string | undefined;
+  isResolved: boolean;
+};

package/src/editJsonFile/editJsonFile.ts

@@ -0,0 +1,30 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { isFunction, merge } from 'remeda';
+import checkExistence from '../checkExistence';
+
+/**
+ * JSONファイルを更新する
+ * @param jsonFilePath
+ * @param editor
+ */
+function editJsonFile(
+  jsonFilePath: string,
+  editor: ((obj: any) => object) | object,
+) {
+  const resolvedJsonFilePath = path.resolve(jsonFilePath);
+  if (checkExistence(resolvedJsonFilePath)) {
+    const obj = fs.readJSONSync(resolvedJsonFilePath);
+    let editedJson;
+    if (isFunction(editor)) {
+      // 関数で編集する場合
+      editedJson = editor(obj);
+    } else {
+      // 差分を反映する場合
+      editedJson = merge(obj, editor);
+    }
+    fs.writeJSONSync(resolvedJsonFilePath, editedJson, { spaces: 2 });
+  }
+}
+
+export default editJsonFile;

package/src/editJsonFile/index.ts

@@ -0,0 +1 @@
+export { default } from './editJsonFile';

package/src/generatePublishPackageJson/generatePublishPackageJson.ts

@@ -0,0 +1,55 @@
+import fs from 'fs-extra';
+import type { GeneratePublishPackageJsonOptions } from './types';
+
+async function generatePublishPackageJson(
+  options: GeneratePublishPackageJsonOptions = {},
+) {
+  const {
+    packageJsonPath = './package.json',
+    outputPackageJsonPath = './dist/package.json',
+    exports = {
+      '.': {
+        import: './index.js',
+        reqire: './index.cjs',
+        type: './index.d.ts',
+      },
+      './*': {
+        import: './*/index.js',
+        reqire: './*/index.cjs',
+        type: './*/index.d.ts',
+      },
+      './constants': {
+        import: './constants.js',
+        reqire: './constants.cjs',
+        type: './constants.d.ts',
+      },
+      './*/constants': {
+        import: './*/constants.js',
+        reqire: './*/constants.cjs',
+        type: './*/constants.d.ts',
+      },
+    },
+    transform = (pkgJson) => pkgJson,
+    jsonReadOptions,
+    jsonWriteOptions,
+  } = options;
+  const packageJson = await fs.readJSON(packageJsonPath, jsonReadOptions);
+  const distPackageJson = {
+    name: packageJson.name,
+    version: packageJson.version,
+    keywords: packageJson.keywords,
+    repository: packageJson.repository,
+    license: packageJson.license,
+    author: packageJson.author,
+    type: packageJson.type,
+    exports,
+    dependencies: packageJson.dependencies,
+  };
+  await fs.writeJSON(
+    outputPackageJsonPath,
+    transform(distPackageJson),
+    jsonWriteOptions,
+  );
+}
+
+export default generatePublishPackageJson;

package/src/generatePublishPackageJson/index.ts

@@ -0,0 +1,2 @@
+export { default } from './generatePublishPackageJson';
+export type * from './types';

package/src/generatePublishPackageJson/types.ts

@@ -0,0 +1,61 @@
+import type { JsonReadOptions, JsonWriteOptions } from 'fs-extra';
+import type { PackageJson } from 'type-fest';
+
+export type GeneratePublishPackageJsonOptions = {
+  /**
+   * package.jsonのパス
+   * @default './package.json'
+   */
+  packageJsonPath?: string;
+
+  /**
+   * 出力先package.jsonファイルのパス
+   * @default './dist/package.json'
+   */
+  outputPackageJsonPath?: string;
+
+  /**
+   * exportsに設定する値
+   * @default
+   * {
+   *   '.': {
+   *     import: './index.js',
+   *     reqire: './index.cjs',
+   *     type: './index.d.ts',
+   *   },
+   *   './*': {
+   *     import: './*\/index.js',
+   *     reqire: './*\/index.cjs',
+   *     type: './*\/index.d.ts',
+   *   },
+   *   './constants': {
+   *     import: './constants.js',
+   *     reqire: './constants.cjs',
+   *     type: './constants.d.ts',
+   *   },
+   *   './*\/constants': {
+   *     import: './*\/constants.js',
+   *     reqire: './*\/constants.cjs',
+   *     type: './*\/constants.d.ts',
+   *   },
+   * }
+   */
+  exports?: PackageJson['exports'];
+
+  /**
+   * 任意の編集を行う関数
+   * @param packageJson 既定の変換を行った後のpackage.jsonの内容
+   * @returns 任意の編集を行った後のpackage.jsonの内容
+   */
+  transform?(packageJson: PackageJson): PackageJson;
+
+  /**
+   * package.json読み込み時のオプション
+   */
+  jsonReadOptions?: JsonReadOptions;
+
+  /**
+   * package.json書き込み時のオプション
+   */
+  jsonWriteOptions?: JsonWriteOptions;
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+export { default as addExports } from './addExports';
+export { default as addJsExtensions } from './addJsExtensions';
+export { default as checkExistence } from './checkExistence';
+export { default as editJsonFile } from './editJsonFile';
+export { default as generatePublishPackageJson } from './generatePublishPackageJson';
+export { default as indexes } from './indexes';
+export { default as installFromLocal } from './installFromLocal';
+export { default as isMatchingPath } from './isMatchingPath';
+export { default as moveFilesToSubdir } from './moveFilesToSubdir';
+export { default as removeFiles } from './removeFiles';
+export { default as ver } from './ver';

package/src/indexes/constants.ts

@@ -0,0 +1,135 @@
+import fs from 'fs-extra';
+import type { IsMatchingPathCondition } from '../isMatchingPath';
+
+/**
+ * types.ts
+ */
+export const TYPES: IsMatchingPathCondition = {
+  valueType: 'base',
+  entryType: 'file',
+  conditions: /^types.ts$/i,
+};
+
+/**
+ * constants.ts
+ */
+export const CONSTANTS: IsMatchingPathCondition = {
+  valueType: 'base',
+  entryType: 'file',
+  conditions: /^constants.(ts|tsx)$/i,
+};
+
+/**
+ * TypeScriptとJavaScript
+ */
+export const TS_JS: IsMatchingPathCondition = {
+  valueType: 'base',
+  entryType: 'file',
+  conditions: /.+\.(ts|tsx|js|jsx)$/i,
+};
+
+/**
+ * 配下にindexファイルのあるディレクトリ
+ */
+export const HAS_INDEX_DIR: IsMatchingPathCondition = {
+  entryType: 'dir',
+  conditions: (values, { indexRegex }) => {
+    const items = fs.readdirSync(values.path);
+    for (const item of items) {
+      if (indexRegex.test(item)) {
+        return true;
+      }
+    }
+    return false;
+  },
+};
+
+/**
+ * テストディレクトリ配下
+ */
+export const TEST_DIR: IsMatchingPathCondition = {
+  valueType: 'path',
+  conditions: /.+\/__test__\/.+/i,
+};
+
+/**
+ * ファイル名またはディレクトリ名が`_`で始まる
+ */
+export const TEST_FILE: IsMatchingPathCondition = {
+  valueType: 'base',
+  conditions: /.*\.test\.(ts|tsx|js|jsx)$/i,
+};
+
+/**
+ * ファイル名またはディレクトリ名が`_`で始まる
+ */
+export const PRIVATE: IsMatchingPathCondition = {
+  valueType: 'base',
+  conditions: /^_/,
+};
+
+/**
+ * 拡張子を除いたファイル名が親ディレクトリ名と同じ
+ */
+export const MAIN_FILE: IsMatchingPathCondition = {
+  entryType: 'file',
+  conditions: (values) => {
+    return values.name === values.dirbase;
+  },
+};
+
+/**
+ * ツール類の入ったディレクトリ
+ */
+export const TOOLS_DIR: IsMatchingPathCondition = {
+  entryType: 'dir',
+  conditions: (values, { children }) => {
+    const { base } = values;
+    return (
+      // 先頭が小文字
+      base[0] === base[0].toLowerCase() &&
+      // 子要素にディレクトリと同じ名称のファイルが無い
+      children?.every((child: string) => child.split('.')[0] !== base)
+    );
+  },
+};
+
+/**
+ * includeのデフォルト値
+ */
+export const DEFAULT_INCLUDE = [
+  // TypeScript,JavaScriptのファイルを対象
+  TS_JS,
+  // 配下にindex.tsを持つディレクトリを対象
+  HAS_INDEX_DIR,
+];
+
+/**
+ * excludeのデフォルト値
+ */
+export const DEFAULT_EXCLUDE = [
+  // __test__フォルダ配下の全てを除外
+  TEST_DIR,
+  // ディレクトリ名、ファイル名が_で始まるものを除外
+  PRIVATE,
+];
+
+/**
+ * exportTypeAllのデフォルト値
+ */
+export const DEFAULT_EXPORT_TYPE_ALL = [TYPES];
+
+/**
+ * exportAllのデフォルト値
+ */
+export const DEFAULT_EXPORT_ALL = [CONSTANTS];
+
+/**
+ * exportDefaultのデフォルト値
+ */
+export const DEFAULT_EXPORT_DEFAULT = [MAIN_FILE];
+
+/**
+ * exportAllAsのデフォルト値
+ */
+export const DEFAULT_EXPORT_ALL_AS = [TOOLS_DIR];

package/src/indexes/index.ts

@@ -0,0 +1,2 @@
+export { default } from './indexes';
+export type * from './types';