@niche-works/dev 0.2.0 → 0.3.0

package/src/indexes/indexes.ts

@@ -0,0 +1,194 @@
+import fs from 'fs-extra';
+import { posix as path } from 'path';
+import isMatchingPath from '../isMatchingPath';
+import {
+  DEFAULT_EXCLUDE,
+  DEFAULT_EXPORT_ALL,
+  DEFAULT_EXPORT_ALL_AS,
+  DEFAULT_EXPORT_DEFAULT,
+  DEFAULT_EXPORT_TYPE_ALL,
+  DEFAULT_INCLUDE,
+} from './constants';
+import type { IndexesOptions } from './types';
+
+const EXPORTS = {
+  exportAll: {
+    type: 'named',
+    generate: (name: string) => `export * from './${name}';`,
+  },
+  exportAllAs: {
+    type: 'named',
+    generate: (name: string) => `export * as ${name} from './${name}';`,
+  },
+  exportDefault: {
+    type: 'default',
+    generate: (name: string) => `export { default } from './${name}';`,
+  },
+  exportDefaultAs: {
+    type: 'named',
+    generate: (name: string) =>
+      `export { default as ${name} } from './${name}';`,
+  },
+  exportTypeAll: {
+    type: 'type',
+    generate: (name: string) => `export type * from './${name}';`,
+  },
+} as const;
+
+/**
+ * 対象のディレクトリ配下のindexファイルを作成する\
+ * 対象ファイルで出力形式が特に指定されていない場合は下記の形式で出力\
+ * `export { default as ${name} } from './${name}';`
+ */
+export default function indexes(options: IndexesOptions = {}) {
+  const {
+    srcPath = 'src',
+    indexFileName = 'index.ts',
+    include = DEFAULT_INCLUDE,
+    exclude = DEFAULT_EXCLUDE,
+    exportAll = DEFAULT_EXPORT_ALL,
+    exportAllAs = DEFAULT_EXPORT_ALL_AS,
+    exportDefault = DEFAULT_EXPORT_DEFAULT,
+    exportTypeAll = DEFAULT_EXPORT_TYPE_ALL,
+    ...rest
+  } = options;
+  const indexRegex = _createRegex(indexFileName);
+
+  // indexファイルの作成処理を実行
+  _indexes(srcPath, indexRegex, {
+    indexFileName,
+    include,
+    exclude,
+    exportAll,
+    exportAllAs,
+    exportDefault,
+    exportTypeAll,
+    ...rest,
+  });
+}
+
+function _indexes(
+  targetPath: string,
+  indexRegex: RegExp,
+  options: IndexesOptions,
+) {
+  const {
+    indexFileName = 'index.ts',
+    include,
+    exclude,
+    includeNamedWithDefault,
+    exportAll,
+    exportAllAs,
+    exportDefault,
+    exportDefaultAs,
+    exportTypeAll,
+    dryRun,
+  } = options;
+  const exportTargets = {
+    exportAll,
+    exportAllAs,
+    exportDefault,
+    exportDefaultAs,
+    exportTypeAll,
+  };
+  const stat = fs.statSync(targetPath);
+  if (!stat.isDirectory()) {
+    console.error(`"${targetPath}" is not directory.`);
+  }
+  const items = fs.readdirSync(targetPath);
+  items.sort((a, b) => (a.toLowerCase() > b.toLowerCase() ? 1 : -1));
+  const exportCodes = [];
+  let hasDefaultExport = false;
+  let hasNamedExport = false;
+
+  for (const item of items) {
+    const itemPath = path.join(targetPath, item);
+    const { name } = path.parse(itemPath);
+    const stat = fs.statSync(itemPath);
+
+    let children;
+    if (stat.isDirectory()) {
+      // ディレクトリの場合は先に子要素を処理
+      children = _indexes(itemPath, indexRegex, options);
+    }
+    const isMatchingPathOptions = {
+      conditionOptions: { indexRegex, children },
+    };
+
+    if (
+      !indexRegex.test(item) &&
+      isMatchingPath(itemPath, include, isMatchingPathOptions) &&
+      !isMatchingPath(itemPath, exclude, isMatchingPathOptions)
+    ) {
+      // indexではない場合
+      let isExported = false;
+      for (const type in EXPORTS) {
+        const exportType = type as keyof typeof EXPORTS;
+        const exportTarget = exportTargets[exportType];
+        if (
+          exportTarget &&
+          isMatchingPath(itemPath, exportTarget, isMatchingPathOptions)
+        ) {
+          // 条件に一致した場合はexportのコードを生成
+          const EXPORT = EXPORTS[exportType];
+          exportCodes.push({
+            type: EXPORT.type,
+            code: EXPORT.generate(name),
+          });
+          // exportの種類に応じたフラグを立てる
+          if (EXPORT.type === 'named') {
+            hasNamedExport = true;
+          } else if (EXPORT.type === 'default') {
+            hasDefaultExport = true;
+          }
+          isExported = true;
+          break;
+        }
+      }
+      if (!isExported) {
+        // 未指定の場合はexportDefaultAs
+        exportCodes.push({
+          type: EXPORTS.exportDefaultAs.type,
+          code: EXPORTS.exportDefaultAs.generate(name),
+        });
+        hasNamedExport = true;
+      }
+    }
+  }
+
+  if (exportCodes.length) {
+    let index;
+    if (hasDefaultExport && hasNamedExport && !includeNamedWithDefault) {
+      // デフォルトエクスポートと名前付きエクスポートの混在を許さない場合は名前付きエクスポートを除外
+      index = exportCodes.reduce<string[]>((result, exportCode) => {
+        if (exportCode.type !== 'named') {
+          result.push(exportCode.code);
+        }
+        return result;
+      }, []);
+    } else {
+      index = exportCodes.map((exportCode) => exportCode.code);
+    }
+
+    const indexPath = path.join(targetPath, indexFileName);
+    if (!dryRun) {
+      // indexファイルの出力
+      fs.writeFileSync(indexPath, index.join('\r\n') + '\r\n', {
+        encoding: 'utf8',
+      });
+      console.info(indexPath);
+    } else {
+      console.info(indexPath + '-------------------------------------');
+      console.info(index.join('\r\n') + '\r\n');
+    }
+  }
+
+  return items;
+}
+
+function _createRegex(str: string) {
+  return new RegExp(
+    `^${str.replace(/[.*+?^=!:${}()|\[\]\/\\]/g, '\\$&')}$`,
+    'i',
+  );
+}

package/src/indexes/types.ts

@@ -0,0 +1,87 @@
+import type { IsMatchingPathCondition } from '../isMatchingPath';
+
+export type IndexesOptions = {
+  /**
+   * 処理対象のパス\
+   * @default `src`
+   */
+  srcPath?: string;
+
+  /**
+   * indexのファイル名\
+   * @default `index.ts`
+   */
+  indexFileName?: string;
+
+  /**
+   * indexファイルを作る対象\
+   * 未指定の場合は下記の条件がデフォルトで適用される
+   *
+   * - ファイル名が`_`で始まらず拡張子が`.ts`,`.tsx`,`.js`,`.jsx`のもの
+   * - ディレクトリ名が`_`で始まらないもの
+   */
+  include?: IsMatchingPathCondition[];
+
+  /**
+   * indexファイルを作る対象から除外するもの
+   */
+  exclude?: IsMatchingPathCondition[];
+
+  /**
+   * 同じindexファイル内にデフォルトエクスポートがある場合でも名前付きエクスポートをする\
+   * デフォルトエクスポートしたモジュールをcjsへ変換したものへアクセスする際に、\
+   * defaultという名前付きでアクセスしても問題ない場合はtrue
+   */
+  includeNamedWithDefault?: boolean;
+
+  /**
+   * exportの形式を下記にしたいもの
+   *
+   * ```
+   * export * from './abc';
+   * ```
+   */
+  exportAll?: IsMatchingPathCondition[];
+
+  /**
+   * exportの形式を下記にしたいもの
+   *
+   * ```
+   * export * as abc from './abc';
+   * ```
+   */
+  exportAllAs?: IsMatchingPathCondition[];
+
+  /**
+   * exportの形式を下記にしたいもの
+   *
+   * ```
+   * export { default } from './abc';
+   * ```
+   */
+  exportDefault?: IsMatchingPathCondition[];
+
+  /**
+   * exportの形式を下記にしたいもの
+   *
+   * ```
+   * export { default as abc } from './abc';
+   * ```
+   */
+  exportDefaultAs?: IsMatchingPathCondition[];
+
+  /**
+   * exportの形式を下記にしたいもの
+   *
+   * ```
+   * export type * from './abc';
+   * ```
+   */
+  exportTypeAll?: IsMatchingPathCondition[];
+
+  /**
+   * お試し\
+   * ファイルの操作は行わない
+   */
+  dryRun?: boolean;
+};

package/src/installFromLocal/index.ts

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

package/{installFromLocal/installFromLocal.js → src/installFromLocal/installFromLocal.ts}

@@ -1,48 +1,63 @@
-import fs from "fs-extra";
-import path from "path";
-import { reduce } from "remeda";
-import checkExistence from "../checkExistence";
-function installFromLocal(localNodeModulesPath, options = {}) {
-  const {
-    packageJsonPath = "./package.json",
-    nodeModulesPath = "./node_modules",
-    dryRun
-  } = options;
-  const resolvedLocalNodeModulesPath = path.resolve(localNodeModulesPath);
-  const resolvedPackageJsonPath = path.resolve(packageJsonPath);
-  if (!checkExistence(resolvedLocalNodeModulesPath, resolvedPackageJsonPath)) {
-    return;
-  }
-  console.info(`${localNodeModulesPath} -> ${nodeModulesPath}`);
-  const packageJson = fs.readJSONSync(resolvedPackageJsonPath);
-  const localPackages = reduce(
-    { ...packageJson.dependencies, ...packageJson.devDependencies },
-    (result, value, key) => {
-      if (value.startsWith(localNodeModulesPath)) {
-        result[key] = value;
-      } else if (value.startsWith(`file:${localNodeModulesPath}`)) {
-        result[key] = value.substring(5);
-      }
-      return result;
-    },
-    {}
-  );
-  for (const packageName in localPackages) {
-    const localPackagePath = path.resolve(localPackages[packageName]);
-    if (fs.existsSync(localPackagePath)) {
-      const installedPackagePath = path.resolve(nodeModulesPath, packageName);
-      if (!dryRun) {
-        if (fs.existsSync(installedPackagePath)) {
-          fs.removeSync(installedPackagePath);
-        }
-        fs.copySync(localPackagePath, installedPackagePath);
-      }
-      console.info(`${packageName} is being copied...`);
-    }
-  }
-}
-var installFromLocal_default = installFromLocal;
-export {
-  installFromLocal_default as default
-};
-//# sourceMappingURL=installFromLocal.js.map
+import fs from 'fs-extra';
+import path from 'path';
+import { reduce } from 'remeda';
+import checkExistence from '../checkExistence';
+import type { InstallFromLocalOptions } from './types';
+
+/**
+ * ローカルに配置されたパッケージを差し替える
+ * @param localNodeModulesPath ローカルのnode_modulesディレクトリのパス
+ * @param options オプション
+ */
+export default function installFromLocal(
+  localNodeModulesPath: string,
+  options: InstallFromLocalOptions = {},
+) {
+  const {
+    packageJsonPath = './package.json',
+    nodeModulesPath = './node_modules',
+    dryRun,
+  } = options;
+  const resolvedLocalNodeModulesPath = path.resolve(localNodeModulesPath);
+  const resolvedPackageJsonPath = path.resolve(packageJsonPath);
+
+  if (!checkExistence(resolvedLocalNodeModulesPath, resolvedPackageJsonPath)) {
+    return;
+  }
+
+  console.info(`${localNodeModulesPath} -> ${nodeModulesPath}`);
+
+  // package.jsonからローカルのnode_modulesにあるパッケージを取得
+  const packageJson = fs.readJSONSync(resolvedPackageJsonPath);
+  const localPackages = reduce(
+    { ...packageJson.dependencies, ...packageJson.devDependencies },
+    (result: Record<string, string>, value: string, key) => {
+      if (value.startsWith(localNodeModulesPath)) {
+        result[key] = value;
+      } else if (value.startsWith(`file:${localNodeModulesPath}`)) {
+        result[key] = value.substring(5);
+      }
+      return result;
+    },
+    {},
+  );
+
+  for (const packageName in localPackages) {
+    // ローカルパッケージの確認
+    const localPackagePath = path.resolve(localPackages[packageName]);
+    if (fs.existsSync(localPackagePath)) {
+      // ローカルパッケージがある場合のみ処理
+      const installedPackagePath = path.resolve(nodeModulesPath, packageName);
+      if (!dryRun) {
+        // コピーを行う
+        if (fs.existsSync(installedPackagePath)) {
+          // 古いパッケージは削除
+          fs.removeSync(installedPackagePath);
+        }
+        // パッケージをコピー
+        fs.copySync(localPackagePath, installedPackagePath);
+      }
+      console.info(`${packageName} is being copied...`);
+    }
+  }
+}

package/src/installFromLocal/types.ts

@@ -0,0 +1,19 @@
+export type InstallFromLocalOptions = {
+  /**
+   * package.jsonのパス
+   * @default './package.json'
+   */
+  packageJsonPath?: string;
+
+  /**
+   * node_modulesのパス
+   * @default './node_modules'
+   */
+  nodeModulesPath?: string;
+
+  /**
+   * お試し
+   * ファイルの操作は行わない
+   */
+  dryRun?: boolean;
+};

package/src/isMatchingPath/_types.ts

@@ -0,0 +1,65 @@
+import type { ParsedPath } from 'path';
+
+/**
+ * 条件設定
+ */
+export type ConditionConfig = {
+  /**
+   * 検査対象の値
+   *
+   * - path: '/'で区切られたフルパス
+   * - base: 拡張子付きのディレクトリ名 or ファイル名
+   * - name: 拡張子を除いたディレクトリ名 or ファイル名
+   * - ext: '.'を含む拡張子。拡張子が無い場合は空文字
+   * - dirpath: '/'で区切られた親ディレクトリのフルパス
+   * - base: 拡張子付きの親ディレクトリ名
+   * - name: 拡張子を除いた親ディレクトリ名
+   * - ext: '.'を含む親ディレクトリの拡張子。拡張子が無い場合は空文字
+   */
+  valueType?:
+    | 'path'
+    | 'base'
+    | 'name'
+    | 'ext'
+    | 'dirpath'
+    | 'dirbase'
+    | 'dirname'
+    | 'dirext';
+
+  /**
+   * 検査対象の種別
+   *
+   * - dir: ディレクトリ
+   * - file: ファイル
+   * - both: ディレクトリ & ファイル
+   */
+  entryType?: 'dir' | 'file' | 'both';
+
+  /**
+   * 一致条件
+   * 配列で指定した場合はand条件とする
+   *
+   * - string: 指定された文字列を含むものに一致
+   * - RegExp: 指定された正規表現に一致
+   */
+  conditions: string | RegExp | ConditionFn | (string | RegExp | ConditionFn)[];
+};
+
+/**
+ * カスタム条件関数
+ */
+export type ConditionFn = (
+  values: ConditionValues,
+  options: Record<string, any>,
+) => boolean;
+
+/**
+ * 検証対象の値
+ */
+export type ConditionValues = {
+  path: string;
+  dirpath: string;
+  dirbase: string;
+  dirname: string;
+  dirext: string;
+} & ParsedPath;

package/src/isMatchingPath/index.ts

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

package/src/isMatchingPath/isMatchingPath.ts

@@ -0,0 +1,88 @@
+import fs from 'fs-extra';
+import { posix as path } from 'path';
+import { isFunction, isString } from 'remeda';
+import type { ConditionValues } from './_types';
+import type { IsMatchingPathCondition, IsMatchingPathOptions } from './types';
+
+/**
+ * 処理対象のパスか判定する
+ * @param targetPath 検査対象のパス
+ * @param conditions 一致条件
+ * @param options オプション
+ * @returns 一致するか
+ */
+export default function isMatchingPath(
+  targetPath: string,
+  conditions:
+    | IsMatchingPathCondition
+    | IsMatchingPathCondition[]
+    | null
+    | undefined,
+  options: IsMatchingPathOptions = {},
+) {
+  if (!conditions) {
+    return false;
+  }
+  const conditionList = Array.isArray(conditions) ? conditions : [conditions];
+  // パスは'/'区切り
+  const posixPath = path.normalize(targetPath);
+  const parsedPath = path.parse(posixPath);
+  const parsedDir = path.parse(parsedPath.dir);
+  const values = {
+    path: posixPath,
+    ...parsedPath,
+    dirpath: parsedPath.dir,
+    dirbase: parsedDir.base,
+    dirname: parsedDir.name,
+    dirext: parsedDir.ext,
+  };
+  values.path = posixPath;
+
+  for (const condition of conditionList) {
+    if (_isMatching(values.path, values, condition, options)) {
+      // conditionの内の何れかがtrueならば一致
+      return true;
+    }
+  }
+  return false;
+}
+
+function _isMatching(
+  value: string,
+  values: ConditionValues,
+  condition: IsMatchingPathCondition,
+  options: IsMatchingPathOptions,
+): boolean {
+  if (isString(condition)) {
+    // 条件が文字列
+    if (value.includes(condition)) {
+      return true;
+    }
+  } else if (condition instanceof RegExp) {
+    // 条件が正規表現
+    if (condition.test(value)) {
+      return true;
+    }
+  } else if (isFunction(condition)) {
+    // 条件が関数
+    return condition(values, options.conditionOptions ?? {});
+  } else {
+    // 条件が設定
+    const { valueType = 'path', entryType = 'both', conditions } = condition;
+    if (entryType !== 'both') {
+      const stat = fs.statSync(values.path);
+      if (
+        (stat.isDirectory() && entryType !== 'dir') ||
+        (stat.isFile() && entryType !== 'file')
+      ) {
+        return false;
+      }
+    }
+    const conditionList = Array.isArray(conditions) ? conditions : [conditions];
+    // 設定配下のconditionsはand条件
+    return conditionList.every((cond) =>
+      _isMatching(values[valueType], values, cond, options),
+    );
+  }
+  return false;
+}

package/src/isMatchingPath/types.ts

@@ -0,0 +1,21 @@
+import type { ConditionConfig, ConditionFn } from './_types';
+
+/**
+ * 一致条件
+ *
+ * - string: 指定された文字列がパスに含まれているものに一致する際にtrue
+ * - RegExp: 指定された正規表現にパスが一致する際にtrue
+ * - ConditionConfig: 条件設定に従って検査し一致したときにtrue
+ */
+export type IsMatchingPathCondition =
+  | string
+  | RegExp
+  | ConditionConfig
+  | ConditionFn;
+
+export type IsMatchingPathOptions = {
+  /**
+   * ConditionFnに渡すオプション
+   */
+  conditionOptions?: Record<string, any>;
+};

package/src/moveFilesToSubdir/index.ts

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

package/src/moveFilesToSubdir/moveFilesToSubdir.ts

@@ -0,0 +1,23 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * 対象のディレクトリ直下のファイルを、拡張子を除いた同名のサブディレクトリ直下に移動する
+ * @param dirPath 対象のディレクトリのパス
+ */
+export default async function moveFilesToSubdir(dirPath: string) {
+  const items = await fs.readdir(dirPath);
+  for (const item of items) {
+    const itemPath = path.join(dirPath, item);
+    const stat = fs.statSync(itemPath);
+    if (stat.isFile()) {
+      const fileName = path.parse(item).name;
+      // 移動先のディレクトリパスを生成
+      const subdirPath = path.join(dirPath, fileName);
+      // 移動先のディレクトリが存在しなければ作成
+      fs.ensureDirSync(subdirPath);
+      // 移動先のファイルパスを生成
+      fs.moveSync(itemPath, path.join(subdirPath, item));
+    }
+  }
+}

package/src/ver/index.ts

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

package/src/ver/types.ts

@@ -0,0 +1,13 @@
+export type VerOptions = {
+  /**
+   * ワークスペースのパッケージjsonのパス
+   * @default `./package.json`
+   */
+  workspacePackageJsonPath?: string;
+
+  /**
+   * パッケージが置かれたディレクトリのパス
+   * @default `./packages`
+   */
+  packagesPath?: string;
+};

package/src/ver/ver.ts

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import path from 'path';
+import type { VerOptions } from './types';
+
+/**
+ * ワークスペースのパッケージにバージョンを反映する
+ * @param version バージョン
+ * @param options オプション
+ */
+export default async function ver(version: string, options: VerOptions = {}) {
+  const {
+    workspacePackageJsonPath = 'package.json',
+    packagesPath = 'packages',
+  } = options;
+
+  if (fs.existsSync(workspacePackageJsonPath)) {
+    // ワークスペースのpackage.jsonを更新
+    _updatePkgJson(version, workspacePackageJsonPath);
+  }
+  const pkgs = fs.readdirSync(packagesPath);
+  for (const pkg of pkgs) {
+    const packagePath = path.join(packagesPath, pkg);
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      // 各パッケージのpackage.jsonを更新
+      _updatePkgJson(version, packageJsonPath);
+    }
+  }
+}
+
+function _updatePkgJson(version: string, packageJsonPath: string) {
+  const packageJson = fs.readJsonSync(packageJsonPath, { encoding: 'utf8' });
+  packageJson.version = version;
+  fs.writeJsonSync(packageJsonPath, packageJson, {
+    encoding: 'utf8',
+    spaces: 2,
+  });
+}