xenopomp-essentials 0.3.1 → 0.3.2

package/__tests__/unit/eslint/config.test.tsx

@@ -0,0 +1,41 @@
+import { expectType } from 'tsd';
+import { describe, expect, test } from 'vitest';
+
+import type { Configs, Options, UserConfigItem } from '@/eslint';
+import xenopomp from '@/eslint';
+import { next } from '@/eslint/configs';
+import type { Fn } from '@/types';
+
+import { assertNotThrowing } from '@test/assets';
+
+type ExpectedType = Fn<
+  [options?: Options, ...userConfigs: UserConfigItem[]],
+  Configs
+>;
+
+describe('xenopomp ESLint config', () => {
+  test('Expected types are not any', () => {
+    expectType<ExpectedType>(xenopomp);
+  });
+
+  test('It does not throw', () => {
+    assertNotThrowing(() => xenopomp());
+
+    assertNotThrowing(() =>
+      xenopomp({
+        react: undefined,
+      }),
+    );
+
+    assertNotThrowing(() =>
+      xenopomp({
+        next: true,
+      }),
+    );
+  });
+
+  test('Next.js integration', async () => {
+    const config = await next();
+    expect(config.length).toBeGreaterThan(0);
+  });
+});

package/__tests__/unit/utils/capitalize.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from 'vitest';
+
+import { capitalize, uncapitalize } from '@/utils';
+
+describe('Capitalize/uncapitalize utilities', () => {
+  test('Capitalize works', () => {
+    const og = 'alex';
+    const cap = capitalize(og);
+    expect(cap).toBe('Alex');
+  });
+
+  test('Uncapitalize works', () => {
+    const og = 'Alex';
+    const cap = uncapitalize(og);
+    expect(cap).toBe('alex');
+  });
+});

package/__tests__/unit/utils/minmax.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'vitest';
+
+import { minmax } from '@/utils';
+
+describe('minmax util', () => {
+  test('Min value', () => {
+    expect(minmax(1, [2, undefined])).toBe(2);
+  });
+
+  test('Max value', () => {
+    expect(minmax(1001, [undefined, 900])).toBe(900);
+  });
+
+  test('Min/Max', () => {
+    const constraint = (num: number) => minmax(num, [100, 500]);
+
+    expect(constraint(1)).toBe(100);
+    expect(constraint(352)).toBe(352);
+    expect(constraint(1000)).toBe(500);
+  });
+});

package/__tests__/unit/utils/parseVersion.test.ts

@@ -0,0 +1,22 @@
+import { describe, test } from 'vitest';
+
+import { parseVersion } from '@/utils';
+import type { VersionData } from '@/utils';
+
+import { assertNotThrowing, expectToDeepEqual } from '@test/assets';
+import { testCases } from '@test/data';
+
+describe('parseVersion util', () => {
+  const testParseVersion = (raw: string, expected: VersionData) => {
+    expectToDeepEqual(parseVersion(raw), expected);
+  };
+
+  test('It does not throw', () => assertNotThrowing(() => parseVersion('')));
+
+  test.each(testCases)(
+    'Test case: input=$input, version=$version, preid=$preid, prerelease=$prerelease',
+    ({ input, ...versionData }) => {
+      testParseVersion(input, versionData);
+    },
+  );
+});

package/__tests__/unit/utils/pipe.test.ts

@@ -0,0 +1,23 @@
+import { expectAssignable } from 'tsd';
+import { describe, test } from 'vitest';
+
+import { pipe } from '@/utils';
+
+import { assertNotThrowing } from '@test/assets';
+
+describe('Pipe function', () => {
+  const testFn = pipe(Date.parse)
+    .pipe(n => new Date(n))
+    .pipe(d => d.toDateString())
+    .pipe(s => s.split('T'))
+    .pipe(([date, time]) => ({ date, time }));
+
+  test('It won`t throw', () => {
+    assertNotThrowing(() => testFn('Jan 1, 2024'));
+  });
+
+  test('Type inference works just fine', () => {
+    const date = testFn('Jan 1, 2024');
+    expectAssignable<{ date?: string; time?: string }>(date);
+  });
+});

package/__tests__/unit/utils/transliterate.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from 'vitest';
+
+import { transliterate } from '@/utils';
+
+import { assertNotThrowing } from '@test/assets';
+
+describe('transliterate util', () => {
+  test('It does not throw', () =>
+    assertNotThrowing(() => transliterate('Я русский')));
+
+  test('It correctly transliterates text', () => {
+    expect(transliterate('Я русский')).toBe('Ya russkiy');
+    expect(transliterate('Ya betonovaya милашка')).toBe(
+      'Ya betonovaya milashka',
+    );
+  });
+});

package/_templates/generator/help/index.ejs.t

@@ -0,0 +1,5 @@
+---
+message: |
+  hygen {bold generator new} --name [NAME] --action [ACTION]
+  hygen {bold generator with-prompt} --name [NAME] --action [ACTION]
+---

package/_templates/generator/new/hello.ejs.t

@@ -0,0 +1,18 @@
+---
+to: _templates/<%= name %>/<%= action || 'new' %>/hello.ejs.t
+---
+---
+to: app/hello.js
+---
+const hello = ```
+Hello!
+This is your first hygen template.
+
+Learn what it can do here:
+
+https://github.com/jondot/hygen
+```
+
+console.log(hello)
+
+

package/_templates/generator/with-prompt/hello.ejs.t

@@ -0,0 +1,18 @@
+---
+to: _templates/<%= name %>/<%= action || 'new' %>/hello.ejs.t
+---
+---
+to: app/hello.js
+---
+const hello = ```
+Hello!
+This is your first prompt based hygen template.
+
+Learn what it can do here:
+
+https://github.com/jondot/hygen
+```
+
+console.log(hello)
+
+

package/_templates/generator/with-prompt/prompt.ejs.t

@@ -0,0 +1,14 @@
+---
+to: _templates/<%= name %>/<%= action || 'new' %>/prompt.js
+---
+
+// see types of prompts:
+// https://github.com/enquirer/enquirer/tree/master/examples
+//
+module.exports = [
+  {
+    type: 'input',
+    name: 'message',
+    message: "What's your message?"
+  }
+]

package/_templates/init/repo/new-repo.ejs.t

@@ -0,0 +1,4 @@
+---
+setup: <%= name %>
+force: true # this is because mostly, people init into existing folders is safe
+---

package/_templates/type/new/module.ejs.t

@@ -0,0 +1,7 @@
+---
+to: src/types/<%= at %>/index.ts
+inject: true
+append: true
+skip_if: <%= h.changeCase.pascalCase(name) %>
+---
+export * from './<%= h.changeCase.pascalCase(name) %>';

package/_templates/type/new/type.ejs.t

@@ -0,0 +1,7 @@
+---
+to: src/types/<%= at %>/<%= h.changeCase.pascalCase(name) %>.ts
+---
+/**
+ * @TODO
+ */
+export type <%= h.changeCase.pascalCase(name) %> = unknown;

package/_templates/util/new/func.ejs.t

@@ -0,0 +1,7 @@
+---
+to: src/utils/<%= h.changeCase.camelCase(name) %>.ts
+---
+/**
+ * @TODO
+ */
+export function <%= h.changeCase.camelCase(name) %>() {}

package/_templates/util/new/module.ejs.t

@@ -0,0 +1,7 @@
+---
+to: src/utils/index.ts
+inject: true
+append: true
+skip_if: <%= h.changeCase.camelCase(name) %>
+---
+export * from './<%= h.changeCase.camelCase(name) %>';

package/_templates/util/new/test.ejs.t

@@ -0,0 +1,13 @@
+---
+to: __tests__/unit/utils/<%= h.changeCase.camelCase(name) %>.test.ts
+---
+import { describe, test } from 'vitest';
+
+import { <%= h.changeCase.camelCase(name) %> } from '@/utils';
+
+import { assertNotThrowing } from '@test/assets';
+
+describe('<%= h.changeCase.camelCase(name) %> util', () => {
+  test('It does not throw', () => assertNotThrowing(() => <%= h.changeCase.camelCase(name) %>()));
+});
+

package/eslint.config.ts

@@ -0,0 +1,17 @@
+import xenopomp from './src/eslint';
+import repoEslintPlugin from './src/repo-eslint-rules';
+
+export default xenopomp(
+  {
+    deprecation: 'warn',
+    tsconfigPath: './.config/ts/tsconfig.lint.json',
+  },
+  {
+    plugins: {
+      repo: repoEslintPlugin,
+    },
+    rules: {
+      'repo/deep-type-naming': 'warn',
+    },
+  },
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xenopomp-essentials",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "author": "XenoPOMP <101574433+XenoPOMP@users.noreply.github.com>",
   "license": "MIT",
   "type": "module",
@@ -13,13 +13,14 @@
     "node": "20 || >=22"
   },
   "scripts": {
-    "build": "run-p build:* && run-p build:packages:*",
+    "build": "run-p build:**",
     "build:main": "unbuild --config .config/build.config.ts",
     "build:packages:cli": "echo CLI",
     "lint": "run-s lint:*",
     "lint:code": "eslint",
     "coverage": "vitest run --coverage -c ./.config/vitest.config.ts",
-    "prepare": "husky"
+    "prepare": "husky",
+    "publish": "yarn install --frozen-lockfile && yarn build"
   },
   "main": "./index.mjs",
   "types": "./index.d.ts",

package/src/cli-tools/changeFile.ts

@@ -0,0 +1 @@
+// export function changeFile() {}

package/src/cli-tools/index.ts

@@ -0,0 +1,2 @@
+// export * from './changeFile';
+export * from './pathBuilder';

package/src/cli-tools/pathBuilder.ts

@@ -0,0 +1,89 @@
+import path from 'node:path';
+
+import { importMeta } from '@/schemas';
+
+/**
+ * Fluent interface for creating paths of application.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * import { PathBuilder } from 'xenopomp-essentials/cli-tools';
+ *
+ * const builder = new PathBuilder();
+ *
+ * const res = builder
+ *  .appSource()
+ *  .cd('./dist/src')
+ *  .file('.prettierrc')
+ *  .build();
+ *
+ *  console.log(res); //? C:/Projects/example/node_modules/xenopomp-essentials/dist/src/.prettierrc
+ */
+export class PathBuilder {
+  private paths: string[] = [];
+
+  private pushPaths(...paths: string[]): PathBuilder {
+    this.paths.push(...paths);
+    return this;
+  }
+
+  /**
+   * Pushes any custom paths to builder.
+   * @since 0.0.1
+   * @param paths
+   */
+  cd(...paths: string[]) {
+    return this.pushPaths(...paths);
+  }
+
+  /**
+   * Pushes filename to paths.
+   * @since 0.0.1
+   * @param fileName
+   */
+  file<T extends `${string}.${string}`>(fileName: T) {
+    return this.pushPaths(`./${fileName}`);
+  }
+
+  /**
+   * Pushes path to compiled app directory.
+   * Is useful for cli tools that have to access files inside their bundles.
+   *
+   * It probably may take no effect (if import.meta is not available in a scope).
+   * If it is, will push cwd.
+   *
+   * @since 0.0.1
+   */
+  appSource(): PathBuilder {
+    if (!importMeta.dirname) {
+      return this.cwd();
+    }
+
+    return this.pushPaths(path.join(path.dirname(importMeta.dirname), '../'));
+  }
+
+  /**
+   * Gets path of directory where script is running. In cli tools it access
+   * path, where cli tool was started.
+   * @since 0.0.1
+   */
+  cwd(): PathBuilder {
+    return this.pushPaths(process.cwd());
+  }
+
+  /**
+   * @since 0.0.1
+   */
+  clear(): PathBuilder {
+    this.paths = [];
+    return this;
+  }
+
+  /**
+   * @since 0.0.1
+   */
+  build(): string {
+    return path.join(...this.paths);
+  }
+}

package/src/eslint/config.ts

@@ -0,0 +1,145 @@
+import type {
+  Awaitable,
+  OptionsConfig,
+  TypedFlatConfigItem,
+} from '@antfu/eslint-config';
+import { antfu } from '@antfu/eslint-config';
+import { deepmerge } from 'deepmerge-ts';
+import type { Linter } from 'eslint';
+
+import type { Undefinable } from '@/types';
+
+import {
+  all,
+  deprecation,
+  markdown,
+  next,
+  old,
+  prettier,
+  react,
+} from './configs';
+import type { Configs, CustomConfig, UserConfigItem } from './types';
+
+interface CustomOptions {
+  deprecation?: Linter.RuleEntry;
+  tsconfigPath?: string;
+}
+export type Options = OptionsConfig &
+  CustomConfig &
+  TypedFlatConfigItem &
+  CustomOptions;
+
+/**
+ * XenoPOMP`s default ESLint config. Uses @antfu/eslint-config under the hood.
+ *
+ * @param options
+ * @param userConfigs
+ *
+ * @example
+ * export default xenopomp(
+ *   // Setup antfu config
+ *   {
+ *     react: true,
+ *     next: false,
+ *   },
+ *   // User configs
+ *   {
+ *     name: 'My custom config',
+ *     rules: { ... }
+ *   },
+ * );
+ */
+export default function xenopomp(
+  options?: Options,
+  ...userConfigs: UserConfigItem[]
+): Configs {
+  const configs: Awaitable<TypedFlatConfigItem[]>[] = [];
+
+  options = {
+    ...options,
+    react: deepmerge<
+      [Undefinable<Options['react']>, Undefinable<Options['react']>]
+    >(true, options?.react),
+
+    vue: deepmerge<[Undefinable<Options['vue']>, Undefinable<Options['vue']>]>(
+      false,
+      options?.vue,
+    ),
+
+    jsonc: deepmerge<
+      [Undefinable<Options['jsonc']>, Undefinable<Options['jsonc']>]
+    >(false, options?.jsonc),
+
+    yaml: deepmerge<
+      [Undefinable<Options['yaml']>, Undefinable<Options['yaml']>]
+    >(false, options?.yaml),
+
+    stylistic: deepmerge<
+      [Undefinable<Options['stylistic']>, Undefinable<Options['stylistic']>]
+    >(
+      {
+        semi: true,
+        quotes: 'single',
+      },
+      options?.stylistic,
+    ),
+
+    typescript: deepmerge<
+      [Undefinable<Options['typescript']>, Undefinable<Options['typescript']>]
+    >(
+      {
+        overrides: {
+          'ts/consistent-type-definitions': ['error', 'interface'],
+          'ts/interface-name-prefix': 'off',
+          'ts/explicit-function-return-type': 'off',
+          'ts/explicit-module-boundary-types': 'off',
+          'ts/no-explicit-any': 'off',
+        },
+      },
+      options?.typescript,
+    ),
+
+    rules: deepmerge<
+      [Undefinable<Options['rules']>, Undefinable<Options['rules']>]
+    >(
+      {
+        'import/order': 'off',
+        'react/react-in-jsx-scope': 'off',
+        'react/prop-types': 'off',
+        'antfu/top-level-function': 'off',
+        'perfectionist/sort-imports': 'off',
+        'perfectionist/sort-named-imports': 'off',
+        'perfectionist/sort-named-exports': 'off',
+        'antfu/consistent-chaining': 'off',
+        'perfectionist/sort-exports': 'off',
+        'style/no-multiple-empty-lines': 'off',
+      },
+      options?.rules,
+    ),
+
+    deprecation: options?.deprecation,
+    tsconfigPath: options?.tsconfigPath,
+  } satisfies Options;
+
+  if (options.react ?? true) configs.push(react());
+
+  if (options.all ?? true) configs.push(all());
+
+  if (options.next ?? false) configs.push(next());
+
+  if (options.markdown ?? true) configs.push(markdown());
+
+  if (options?.deprecation) {
+    configs.push(
+      deprecation(options?.deprecation ?? 'warn', {
+        tsconfigPath: options?.tsconfigPath,
+      }),
+    );
+  }
+
+  // Apply other configs
+  configs.push(old());
+  configs.push(prettier());
+
+  return antfu(options, ...configs, ...userConfigs);
+}

package/src/eslint/configs/all.ts

@@ -0,0 +1,74 @@
+import type { TypedFlatConfigItem } from '@antfu/eslint-config';
+
+import { AUTHOR_NAME_LOWER } from '../prefixes';
+
+export async function all(): Promise<TypedFlatConfigItem[]> {
+  return [
+    {
+      name: `${AUTHOR_NAME_LOWER}:all`,
+      rules: {
+        'antfu/no-cjs-exports': 'off',
+
+        'import/prefer-default-export': 'off',
+        'import/extensions': 'off',
+        'no-restricted-globals': 'off',
+
+        'node/prefer-global/process': 'off',
+
+        'jsonc/comma-dangle': 'off',
+        'style/jsx-quotes': ['error', 'prefer-double'],
+        'style/jsx-one-expression-per-line': [
+          'error',
+          { allow: 'single-line' },
+        ],
+        'style/arrow-parens': ['error', 'as-needed'],
+
+        'unused-imports/no-unused-imports': 'error',
+        'unused-imports/no-unused-vars': [
+          'warn',
+          {
+            vars: 'all',
+            varsIgnorePattern: '^_',
+            args: 'after-used',
+            argsIgnorePattern: '^_',
+          },
+        ],
+        '@stylistic/indent': [
+          'error',
+          2,
+          {
+            ArrayExpression: 1,
+            CallExpression: {
+              arguments: 1,
+            },
+            flatTernaryExpressions: false,
+            FunctionDeclaration: {
+              body: 1,
+              parameters: 1,
+            },
+            FunctionExpression: {
+              body: 1,
+              parameters: 1,
+            },
+            ignoreComments: false,
+            ignoredNodes: [
+              'TemplateLiteral *',
+              'TSIntersectionType',
+              'TSTypeParameterInstantiation',
+              'FunctionExpression > .params[decorators.length > 0]',
+              'FunctionExpression > .params > :matches(Decorator, :not(:first-child))',
+              'ClassBody.body > PropertyDefinition[decorators.length > 0] > .key',
+            ],
+            ImportDeclaration: 1,
+            MemberExpression: 1,
+            ObjectExpression: 1,
+            offsetTernaryExpressions: true,
+            outerIIFEBody: 1,
+            SwitchCase: 1,
+            VariableDeclarator: 1,
+          },
+        ],
+      },
+    },
+  ];
+}

package/src/eslint/configs/deprecation.ts

@@ -0,0 +1,33 @@
+import type { TypedFlatConfigItem } from '@antfu/eslint-config';
+import { fixupPluginRules } from '@eslint/compat';
+import type { Linter } from 'eslint';
+import plugin from 'eslint-plugin-deprecation';
+
+import type { Options as ConfigOptions } from '../config';
+
+type Options = Pick<ConfigOptions, 'tsconfigPath'>;
+
+export async function deprecation(
+  severity: Linter.RuleEntry,
+  options?: Options,
+): Promise<TypedFlatConfigItem[]> {
+  return [
+    {
+      name: 'Deprecation plugin',
+      languageOptions: {
+        parserOptions: {
+          project: options?.tsconfigPath ?? './tsconfig.json',
+          projectSource: true,
+        },
+      },
+      plugins: {
+        // @ts-expect-error Wrong library types
+        deprecation: fixupPluginRules(plugin),
+      },
+      rules: {
+        'deprecation/deprecation': severity,
+      },
+      files: ['**/*.ts', '**/*.tsx'],
+    },
+  ];
+}

package/src/eslint/configs/index.ts

@@ -0,0 +1,7 @@
+export * from './react';
+export * from './next';
+export * from './markdown';
+export * from './all';
+export * from './old';
+export * from './prettier';
+export * from './deprecation';