@niche-works/dev 0.4.1 → 0.4.2

package/src/generatePublishPackageJson/generatePublishPackageJson.ts

@@ -1,55 +0,0 @@
-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

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

package/src/index.ts

@@ -1,11 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

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

package/src/indexes/indexes.ts

@@ -1,194 +0,0 @@
-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/installFromLocal/index.ts

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

package/src/installFromLocal/installFromLocal.ts

@@ -1,63 +0,0 @@
-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/isMatchingPath/index.ts

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

package/src/isMatchingPath/isMatchingPath.ts

@@ -1,94 +0,0 @@
-import fs from 'fs-extra';
-import { posix as path } from 'path';
-import { isFunction, isString } from 'remeda';
-import type {
-  ConditionFnOptions,
-  ConditionValues,
-  IsMatchingPathCondition,
-  IsMatchingPathOptions,
-} from './types';
-
-/**
- * 処理対象のパスか判定する
- * @param targetPath 検査対象のパス
- * @param conditions 一致条件
- * @param options オプション
- * @returns 一致するか
- */
-export default function isMatchingPath<
-  O extends ConditionFnOptions = ConditionFnOptions,
->(
-  targetPath: string,
-  conditions:
-    | IsMatchingPathCondition<O>
-    | IsMatchingPathCondition<O>[]
-    | null
-    | undefined,
-  options: IsMatchingPathOptions<O> = {},
-) {
-  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<O extends ConditionFnOptions = ConditionFnOptions>(
-  value: string,
-  values: ConditionValues,
-  condition: IsMatchingPathCondition<O>,
-  options: IsMatchingPathOptions<O>,
-): 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 ?? {}) as O);
-  } 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

@@ -1,95 +0,0 @@
-import type { ParsedPath } from 'path';
-
-/**
- * 一致条件
- *
- * - string: 指定された文字列がパスに含まれているものに一致する際にtrue
- * - RegExp: 指定された正規表現にパスが一致する際にtrue
- * - ConditionConfig: 条件設定に従って検査し一致したときにtrue
- */
-export type IsMatchingPathCondition<
-  O extends ConditionFnOptions = ConditionFnOptions,
-> = string | RegExp | ConditionConfig<O> | ConditionFn<O>;
-
-export type IsMatchingPathOptions<
-  O extends ConditionFnOptions = ConditionFnOptions,
-> = {
-  /**
-   * ConditionFnに渡すオプション
-   */
-  conditionOptions?: O;
-};
-
-/**
- * 条件設定
- */
-export type ConditionConfig<O extends ConditionFnOptions = ConditionFnOptions> =
-  {
-    /**
-     * 検査対象の値
-     *
-     * - 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<O>
-      | (string | RegExp | ConditionFn<O>)[];
-  };
-
-/**
- * カスタム条件関数
- */
-export type ConditionFn<O extends ConditionFnOptions = ConditionFnOptions> = (
-  values: ConditionValues,
-  options: O,
-) => boolean;
-
-/**
- * カスタム条件関数のオプション
- */
-export type ConditionFnOptions = Record<string, any>;
-
-/**
- * 検証対象の値
- */
-export type ConditionValues = {
-  path: string;
-  dirpath: string;
-  dirbase: string;
-  dirname: string;
-  dirext: string;
-} & ParsedPath;

package/src/isTargetPath/index.ts

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

package/src/isTargetPath/isTargetPath.ts

@@ -1,30 +0,0 @@
-import fs, { Stats } from 'fs-extra';
-import type { ConditionFnOptions } from '../isMatchingPath';
-import isMatchingPath from '../isMatchingPath';
-import type { IsTargetPathOptions } from './types';
-
-const IS_TARGET_TYPE = {
-  file: (stat: Stats) => stat.isFile(),
-  dir: (stat: Stats) => stat.isDirectory(),
-  both: (stat: Stats) => stat.isFile() || stat.isDirectory(),
-} as const;
-
-export default async function isTargetPath<
-  O extends ConditionFnOptions = ConditionFnOptions,
->(itemPath: string, options: IsTargetPathOptions<O> = {}) {
-  const {
-    itemType = 'file',
-    defaultInclude,
-    defaultExclude,
-    include = defaultInclude,
-    exclude = defaultExclude,
-    ...rest
-  } = options;
-  const stat = fs.statSync(itemPath);
-
-  return (
-    IS_TARGET_TYPE[itemType](stat) &&
-    (!include || isMatchingPath(itemPath, include, rest)) &&
-    (!exclude || !isMatchingPath(itemPath, exclude, rest))
-  );
-}