((resolve, reject) => {
115 | if (!isBrowser) {
116 | reject()
117 | return
118 | }
119 |
120 | const callbackByUrl = getQuery(url)
121 | const cb =
122 | callbackByUrl ||
123 | callback ||
124 | `jsonp_callback_${randomString().replace(/-/g, '_')}`
125 |
126 | // @ts-expect-error
127 | window[cb] = (data: T) => {
128 | try {
129 | // @ts-expect-error
130 | // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
131 | delete window[cb]
132 | } catch {
133 | // @ts-expect-error
134 | window[cb] = undefined
135 | }
136 | document.body.removeChild(script)
137 | resolve(data)
138 | }
139 |
140 | const separator = url.includes('?') ? '&' : '?'
141 | const scriptUrl = url.includes('callback')
142 | ? url
143 | : url + separator + 'callback=' + cb
144 |
145 | const script = document.createElement('script')
146 | script.src = scriptUrl
147 | script.onerror = reject
148 | document.body.appendChild(script)
149 | })
150 | }
151 |
152 | /**
153 | * Load a batch of images in concurrent mode
154 | *
155 | * @category Network
156 | */
157 | export function concurrentLoadImages(images: string[]) {
158 | const promises = []
159 |
160 | for (const path in images) {
161 | promises.push(
162 | new Promise((resolve, reject) => {
163 | const img = new Image()
164 | img.onload = resolve
165 | img.onerror = reject
166 | img.src = path
167 | }),
168 | )
169 | }
170 |
171 | return Promise.all(promises)
172 | }
173 |
174 | /**
175 | * Load a batch of images in serial mode
176 | *
177 | * @category Network
178 | */
179 | export async function serialLoadImages(images: string[]) {
180 | for (const path in images) {
181 | await concurrentLoadImages([path])
182 | }
183 | }
184 |
185 | /**
186 | * Preload images
187 | *
188 | * It can be used to preload large images in advance, or wait for the image to
189 | * be loaded before ending Loading and other usage scenarios.
190 | *
191 | * @category Network
192 | * @example
193 | * ;```ts
194 | * const images = [
195 | * 'https://example.com/1.jpg',
196 | * 'https://example.com/2.jpg',
197 | * 'https://example.com/3.jpg',
198 | * ]
199 | *
200 | * // Start loading, Show loading icon etc.
201 | * setLoading(true)
202 | *
203 | * // Wait for the images to be pre-rendered
204 | * await preloadImages(images)
205 | *
206 | * // End loading state
207 | * setLoading(false)
208 | * ```
209 | *
210 | * @param images - An array containing image urls
211 | * @param mode - Concurrent mode is used by default. If there are too many
212 | * pictures, you can choose serial mode.
213 | */
214 | export async function preloadImages(
215 | images: string[],
216 | mode: 'concurrent' | 'serial' = 'concurrent',
217 | ) {
218 | switch (mode) {
219 | case 'concurrent': {
220 | await concurrentLoadImages(images)
221 | break
222 | }
223 |
224 | case 'serial': {
225 | await serialLoadImages(images)
226 | break
227 | }
228 |
229 | default: {
230 | await pnoop()
231 | break
232 | }
233 | }
234 | }
235 |
--------------------------------------------------------------------------------
/packages/utils/test/format.spec.ts:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest'
2 | import {
3 | extractNumber,
4 | formatAmount,
5 | ellipsis,
6 | capitalize,
7 | kebabCase,
8 | camelCase,
9 | pascalCase,
10 | escapeRegExp,
11 | sortKeys,
12 | unique,
13 | excludeFields,
14 | formatTime,
15 | formatDuration,
16 | removeHtmlTags,
17 | toArray,
18 | ensurePrefix,
19 | ensureSuffix,
20 | } from '..'
21 |
22 | describe('format', () => {
23 | it('extractNumber', () => {
24 | expect(extractNumber('akdhaskd2')).toBe('2')
25 | expect(extractNumber('阿斯0达克哈1234克qqwer5')).toBe('12345')
26 | })
27 |
28 | it('formatAmount', () => {
29 | expect(formatAmount('4')).toBe('4.00')
30 | expect(formatAmount('1.5')).toBe('1.50')
31 | expect(formatAmount('0.44565')).toBe('0.45')
32 | })
33 |
34 | it('ellipsis', () => {
35 | expect(ellipsis('Hello World', 5)).toBe('Hello ...')
36 | expect(ellipsis('Hello World', 8)).toBe('Hello Wo ...')
37 | })
38 |
39 | it('capitalize', () => {
40 | expect(capitalize('4')).toBe('4')
41 | expect(capitalize('a')).toBe('A')
42 | expect(capitalize('abc')).toBe('Abc')
43 | expect(capitalize('abc')).toBe('Abc')
44 | expect(capitalize('abcDef')).toBe('AbcDef')
45 | expect(capitalize('!abc')).toBe('!abc')
46 | expect(capitalize('')).toBe('')
47 | })
48 |
49 | it('kebabCase', () => {
50 | expect(kebabCase('4')).toBe('4')
51 | expect(kebabCase('a')).toBe('a')
52 | expect(kebabCase('AbcDef')).toBe('abc-def')
53 | expect(kebabCase('Abc-Def')).toBe('abc--def')
54 | expect(kebabCase('abc_efg_hijklmn')).toBe('abc-efg-hijklmn')
55 | expect(kebabCase('!abc')).toBe('!abc')
56 | expect(kebabCase('')).toBe('')
57 | })
58 |
59 | it('camelCase', () => {
60 | expect(camelCase('4')).toBe('4')
61 | expect(camelCase('a')).toBe('a')
62 | expect(camelCase('AbcDef')).toBe('abcDef')
63 | expect(camelCase('Abc-Def')).toBe('abcDef')
64 | expect(camelCase('abc_efg_hijklmn')).toBe('abcEfgHijklmn')
65 | expect(camelCase('!abc')).toBe('!abc')
66 | expect(camelCase('')).toBe('')
67 | })
68 |
69 | it('pascalCase', () => {
70 | expect(pascalCase('4')).toBe('4')
71 | expect(pascalCase('a')).toBe('A')
72 | expect(pascalCase('AbcDef')).toBe('AbcDef')
73 | expect(pascalCase('Abc-Def')).toBe('AbcDef')
74 | expect(pascalCase('abc_efg_hijklmn')).toBe('AbcEfgHijklmn')
75 | expect(pascalCase('!abc')).toBe('!abc')
76 | expect(pascalCase('')).toBe('')
77 | })
78 |
79 | it('escapeRegExp', () => {
80 | expect(escapeRegExp('@bassist/utils')).toBe('@bassist/utils')
81 | expect(escapeRegExp('https://example.com/foo')).toBe(
82 | 'https://example\\.com/foo',
83 | )
84 | })
85 |
86 | it('sortKeys', () => {
87 | expect(
88 | sortKeys({
89 | c: 3,
90 | d: { c: 3, a: 1, b: 2 },
91 | a: 1,
92 | e: [
93 | { c: 3, a: 1, b: 2 },
94 | { c: 3, a: 1, b: 2 },
95 | ],
96 | b: 2,
97 | }),
98 | ).toEqual({
99 | a: 1,
100 | b: 2,
101 | c: 3,
102 | d: { a: 1, b: 2, c: 3 },
103 | e: [
104 | { a: 1, b: 2, c: 3 },
105 | { a: 1, b: 2, c: 3 },
106 | ],
107 | })
108 |
109 | expect(
110 | sortKeys([
111 | { c: 3, a: 1, b: 2 },
112 | { c: 3, a: 1, b: 2 },
113 | ]),
114 | ).toEqual([
115 | { a: 1, b: 2, c: 3 },
116 | { a: 1, b: 2, c: 3 },
117 | ])
118 |
119 | expect(null).toBeNull()
120 | expect(undefined).toBeUndefined()
121 | expect('foo').toBe('foo')
122 | })
123 |
124 | it('unique', () => {
125 | expect(
126 | unique({
127 | primaryKey: 'foo',
128 | list: [
129 | { foo: 1, bar: 1 },
130 | { foo: 1, bar: 2 },
131 | { foo: 2, bar: 1 },
132 | ],
133 | }),
134 | ).toEqual([
135 | { foo: 1, bar: 1 },
136 | { foo: 2, bar: 1 },
137 | ])
138 |
139 | expect(
140 | unique({
141 | primaryKey: 'bar',
142 | list: [
143 | { foo: 1, bar: 1 },
144 | { foo: 1, bar: 2 },
145 | { foo: 2, bar: 1 },
146 | ],
147 | }),
148 | ).toEqual([
149 | { foo: 1, bar: 1 },
150 | { foo: 1, bar: 2 },
151 | ])
152 |
153 | expect(
154 | unique({
155 | primaryKey: 'foo',
156 | list: [
157 | { foo: 1, bar: 1 },
158 | { foo: 2, bar: null },
159 | { foo: 3, bar: [1, 2, 3] },
160 | { foo: 3, bar: [] },
161 | ],
162 | }),
163 | ).toEqual([
164 | { foo: 1, bar: 1 },
165 | { foo: 2, bar: null },
166 | { foo: 3, bar: [1, 2, 3] },
167 | ])
168 | })
169 |
170 | it('excludeFields', () => {
171 | const obj = {
172 | foo: 'foo',
173 | bar: 'bar',
174 | baz: {
175 | foo: 'foo',
176 | bar: 'bar',
177 | },
178 | num: 1,
179 | bool: true,
180 | }
181 |
182 | expect(excludeFields(obj, ['foo', 'bar'])).toEqual({
183 | baz: {
184 | foo: 'foo',
185 | bar: 'bar',
186 | },
187 | num: 1,
188 | bool: true,
189 | })
190 |
191 | expect(excludeFields(obj, ['baz', 'num'])).toEqual({
192 | foo: 'foo',
193 | bar: 'bar',
194 | bool: true,
195 | })
196 |
197 | expect(excludeFields(obj, [])).toEqual(obj)
198 | expect(excludeFields(obj, ['test'])).toEqual(obj)
199 | })
200 |
201 | it('formatTime', () => {
202 | // A date string in standard ISO 8601 format
203 | expect(formatTime(new Date('2023-01-01'))).toBe('2023-01-01 08:00:00')
204 |
205 | // Non-standard date string format
206 | expect(formatTime(new Date('2023/01/01'))).toBe('2023-01-01 00:00:00')
207 |
208 | expect(formatTime(new Date('2023-01-01 14:05:59'))).toBe(
209 | '2023-01-01 14:05:59',
210 | )
211 | expect(formatTime(new Date('2023-01-01 00:05:59'))).toBe(
212 | '2023-01-01 00:05:59',
213 | )
214 | expect(formatTime(new Date('2023/01/01 00:05:59'))).toBe(
215 | '2023-01-01 00:05:59',
216 | )
217 | expect(formatTime(new Date('2023-01-01 14:05:59'), true)).toBe('2023-01-01')
218 | })
219 |
220 | it('formatDuration', () => {
221 | expect(
222 | formatDuration(+new Date('2023-01-02') - +new Date('2023-01-01')),
223 | ).toBe('1 天')
224 |
225 | expect(
226 | formatDuration(
227 | +new Date('2023-01-02 04:00:00') - +new Date('2023-01-01 00:00:00'),
228 | ),
229 | ).toBe('1 天 4 小时')
230 |
231 | expect(
232 | formatDuration(
233 | +new Date('2023-01-02 04:15:00') - +new Date('2023-01-01 00:00:00'),
234 | ),
235 | ).toBe('1 天 4 小时 15 分钟')
236 |
237 | expect(
238 | formatDuration(
239 | +new Date('2023-01-12 04:15:36') - +new Date('2023-01-01 00:00:00'),
240 | ),
241 | ).toBe('11 天 4 小时 15 分钟 36 秒')
242 |
243 | expect(
244 | formatDuration(
245 | +new Date('2023-01-12 04:15:36') - +new Date('2023-01-01 00:00:00'),
246 | {
247 | days: 'Days',
248 | hours: 'Hours',
249 | minutes: 'Minutes',
250 | seconds: 'Seconds',
251 | },
252 | ),
253 | ).toBe('11 Days 4 Hours 15 Minutes 36 Seconds')
254 | })
255 |
256 | it('removeHtmlTags', () => {
257 | expect(removeHtmlTags('hello')).toBe('hello')
258 | expect(removeHtmlTags('
hello world')).toBe('hello world')
259 | })
260 |
261 | it('toArray', () => {
262 | expect(toArray([1, 2, 3])).toEqual([1, 2, 3])
263 | expect(toArray(1)).toEqual([1])
264 | expect(toArray()).toEqual([])
265 | })
266 |
267 | it('ensurePrefix', () => {
268 | expect(ensurePrefix('https://', 'https://example.com')).toBe(
269 | 'https://example.com',
270 | )
271 | expect(ensurePrefix('https://', 'example.com')).toBe('https://example.com')
272 | })
273 |
274 | it('ensureSuffix', () => {
275 | expect(ensureSuffix('/', '/path/to')).toBe('/path/to/')
276 | expect(ensureSuffix('/', '/path/to/')).toBe('/path/to/')
277 | })
278 | })
279 |
--------------------------------------------------------------------------------
/packages/eslint-config/README.zh-CN.md:
--------------------------------------------------------------------------------
1 | # @bassist/eslint-config
2 |
3 |
4 |
5 | 
6 |
7 |
8 | 
9 |
10 |
11 | 
12 |
13 |
14 | 
15 |
16 |
17 |
18 | [English](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/README.md) | 简体中文
19 |
20 | 一款现代化的扁平 ESLint 配置，适用于 [ESLint](https://eslint.org/) V9 ，由 [@chengpeiquan](https://github.com/chengpeiquan) 精心打造。
21 |
22 | ## ⚡ 使用方法
23 |
24 | 使用此 ESLint 配置仅需三步：
25 |
26 | 1. 安装依赖（参考：[🚀 安装](#-安装)）
27 | 2. 添加 ESLint 配置文件（参考：[📂 配置文件](#-配置文件)）
28 | 3. 在 VS Code 的 `settings.json` 启用自动 Lint（参考：[🛠 VS Code 配置](#-vs-code-配置)）
29 |
30 | 这个快速指南可以作为入门辅助，避免遗漏关键步骤 🚀 。
31 |
32 | ## 🚀 安装
33 |
34 | 使用常用的包管理器安装该包：
35 |
36 | ```bash
37 | npm install -D eslint @bassist/eslint-config
38 | ```
39 |
40 | **注意：** 需要 ESLint 版本 >= `9.0.0` ，以及 TypeScript 版本 >= `5.0.0`。
41 |
42 | 如果使用的是 `pnpm`，建议在项目根目录添加 `.npmrc` 文件，并包含以下配置，以更顺利地处理 peer 依赖：
43 |
44 | ```ini
45 | shamefully-hoist=true
46 | auto-install-peers=true
47 | ```
48 |
49 | > 如果仍在使用 ESLint v8，请参考旧版（已不再维护）包：[@bassist/eslint](https://www.npmjs.com/package/@bassist/eslint)。
50 |
51 | ## 📂 配置文件
52 |
53 | 在项目根目录创建 `eslint.config.js` 文件：
54 |
55 | ```js
56 | // eslint.config.js
57 | import { imports, typescript } from '@bassist/eslint-config'
58 |
59 | // 导出一个包含多个配置对象的数组
60 | export default [...imports, ...typescript]
61 | ```
62 |
63 | 然后在 `package.json` 中添加 "type": "module" ：
64 |
65 | ```json
66 | {
67 | "type": "module",
68 | "scripts": {
69 | "lint": "eslint src",
70 | "lint:inspector": "npx @eslint/config-inspector"
71 | }
72 | }
73 | ```
74 |
75 | 运行 `npm run lint` 以检查代码，或运行 `npm run lint:inspector` 在 `http://localhost:7777` 查看可视化的 ESLint 配置。
76 |
77 | > 对于 TypeScript 配置文件（例如 `eslint.config.ts` ），需要 [额外的设置](https://eslint.org/docs/latest/use/configure/configuration-files#typescript-configuration-files) 。
78 |
79 | ```bash
80 | # 为 Node.js 提供运行时 TypeScript 和 ESM 支持
81 | # 才可以使用 `eslint.config.ts` 作为配置文件
82 | npm install -D jiti
83 | ```
84 |
85 | ## ✅ 类型安全的配置
86 |
87 | 为了增强类型安全性，可以使用 `defineFlatConfig`:
88 |
89 | ```js
90 | // @ts-check
91 | import { defineFlatConfig, imports, vue } from '@bassist/eslint-config'
92 |
93 | export default defineFlatConfig([
94 | ...imports,
95 | ...vue,
96 | // 添加更多自定义配置
97 | {
98 | // 为每个配置提供名称，以便在运行 `npm run lint:inspector` 时，
99 | // 可以在可视化工具中清晰展示
100 | name: 'my-custom-rule/vue',
101 | rules: {
102 | // 例如：默认情况下，该规则是 `off`
103 | 'vue/component-tags-order': 'error',
104 | },
105 | ignores: ['examples'],
106 | },
107 | ])
108 | ```
109 |
110 | ## 🛠 VS Code 配置
111 |
112 | 在 VS Code 工作区的 `settings.json` 添加以下配置，以启用自动 Lint 修复：
113 |
114 | ```json
115 | {
116 | "editor.formatOnSave": true,
117 | "editor.codeActionsOnSave": {
118 | "source.fixAll.eslint": "always",
119 | "source.fixAll.prettier": "always"
120 | },
121 | "editor.defaultFormatter": "esbenp.prettier-vscode",
122 | "eslint.useFlatConfig": true,
123 | "eslint.format.enable": true,
124 | "eslint.validate": [
125 | "javascript",
126 | "javascriptreact",
127 | "typescript",
128 | "typescriptreact"
129 | ],
130 | "prettier.configPath": "./.prettierrc.js"
131 | }
132 | ```
133 |
134 | 关于 `prettier.configPath` 请查看 [格式化工具](#格式化工具) 部分。
135 |
136 | ## 📘 API 参考
137 |
138 | ### defineFlatConfig
139 |
140 | 定义 ESLint 配置，可选支持 Prettier 和 Tailwind CSS。
141 |
142 | API 类型声明：
143 |
144 | ```ts
145 | /**
146 | * 定义 ESLint 配置，可选支持 Prettier 集成。
147 | *
148 | * @param configs 基础 ESLint 配置数组。
149 | * @param options - 配置选项。
150 | * @returns 最终的 ESLint 配置数组。
151 | */
152 | declare const defineFlatConfig: (
153 | configs: FlatESLintConfig[],
154 | options?: DefineFlatConfigOptions,
155 | ) => FlatESLintConfig[]
156 | ```
157 |
158 | 选项类型声明：
159 |
160 | ```ts
161 | interface DefineFlatConfigOptions {
162 | /**
163 | * 指定用于加载 `.prettierrc` 配置的工作目录。
164 | *
165 | * 配置文件应为 JSON 格式。
166 | *
167 | * @default process.cwd()
168 | */
169 | cwd?: string
170 |
171 | /**
172 | * 如果 `prettierEnabled` 设为 `false`，则所有与 Prettier 相关的规则和配置都将被忽略， 即使提供了
173 | * `prettierRules` 也不会生效。
174 | *
175 | * @default true
176 | */
177 | prettierEnabled?: boolean
178 |
179 | /**
180 | * 默认情况下，会从当前工作目录读取 `.prettierrc`，并且 `.prettierrc` 文件必须是 JSON 格式。
181 | *
182 | * 如果配置文件不是 JSON 格式，或者使用了不同的文件名，可以将其转换为 JSON 规则后传入。
183 | *
184 | * 读取自定义配置后，会与默认的 ESLint 规则合并。
185 | *
186 | * @see https://prettier.io/docs/configuration.html
187 | */
188 | prettierRules?: PartialPrettierExtendedOptions
189 |
190 | /**
191 | * Tailwind CSS 规则默认启用。如果它们影响了项目，可以通过该选项禁用。
192 | *
193 | * @default true
194 | */
195 | tailwindcssEnabled?: boolean
196 |
197 | /**
198 | * 如果需要覆盖 Tailwind CSS 配置，可以传入相应的选项。
199 | *
200 | * 如果想要合并配置，可以导入 `defaultTailwindcssSettings`，手动合并后再传入。
201 | *
202 | * 如果传入空对象 `{}`，则会使用默认设置。
203 | *
204 | * @see https://github.com/francoismassart/eslint-plugin-tailwindcss/tree/v3.18.2
205 | */
206 | tailwindcssSettings?: TailwindcssSettings
207 | }
208 | ```
209 |
210 | ### createGetConfigNameFactory
211 |
212 | `createGetConfigNameFactory` 是一个灵活的工具函数，用于生成 ESLint 配置命名工具。它可以快速拼接配置名称，确保命名空间一致，并便于组织和管理复杂的规则集。
213 |
214 | API 类型声明：
215 |
216 | ```ts
217 | /**
218 | * 一个灵活的工具函数，用于生成 ESLint 配置命名工具。 它可以快速拼接配置名称，确保命名空间一致，并便于组织和管理复杂的规则集。
219 | *
220 | * @param prefix - 表示配置名称前缀的字符串。
221 | * @returns 一个函数，该函数会将提供的名称片段与指定的前缀拼接在一起。
222 | */
223 | declare const createGetConfigNameFactory: (
224 | prefix: string,
225 | ) => (...names: string[]) => string
226 | ```
227 |
228 | 使用示例：
229 |
230 | ```ts
231 | import {
232 | createGetConfigNameFactory,
233 | defineFlatConfig,
234 | } from '@bassist/eslint-config'
235 |
236 | const getConfigName = createGetConfigNameFactory('my-prefix')
237 |
238 | export default defineFlatConfig([
239 | {
240 | name: getConfigName('ignore'), // --> `my-prefix/ignore`
241 | ignores: ['**/dist/**', '**/.build/**', '**/CHANGELOG.md'],
242 | },
243 | ])
244 | ```
245 |
246 | 为什么要使用它？
247 |
248 | - 一致性：强制执行清晰统一的配置命名模式。
249 | - 灵活性：允许为不同项目或范围自定义前缀。
250 | - 简化管理：便于组织和浏览大型 ESLint 配置。
251 |
252 | 这个工具在构建可复用的 ESLint 配置或维护复杂项目的规则集时尤其有用。
253 |
254 | ## 📦 导出的配置
255 |
256 | 这些是一些常用的配置，如果有额外需求，欢迎提交 PR！
257 |
258 | ### 语言支持
259 |
260 | - [JavaScript](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/javascript.ts)
261 | - [TypeScript](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/typescript.ts)
262 | - [JSX](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/jsx.ts)
263 | - [Markdown](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/markdown.ts)
264 |
265 | #### 框架支持
266 |
267 | - [Next.js](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/next.ts)
268 | - [React](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/react.ts)
269 | - [Vue (v2 and v3)](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/vue.ts)
270 |
271 | #### 格式化工具
272 |
273 | 格式化规则默认启用，不会单独导出。如需自定义配置，请通过 [defineFlatConfig API](#defineflatconfig) 的 `options` 传入。
274 |
275 | - [Prettier](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/private-configs/prettier.ts) :
276 | - 默认会读取 `.prettierrc` 和 `.prettierignore` 的内容，并添加到 ESLint 规则中。
277 | - 如果预期的配置文件不存在，则会使用 [内置的 Prettier](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/shared/prettier-config.mjs) 规则作为兜底规则。
278 | - 非以上配置文件并且不喜欢默认规则时，可以通过 [defineFlatConfig](#defineflatconfig) 的 `options.prettierRules` 将完整配置传递进来优先作为 ESLint 规则使用
279 | - [Tailwind CSS](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/private-configs/tailwindcss.ts) :
280 | - 默认会将 `tailwind.config.js` 作为 Tailwind CSS 配置文件传入。
281 | - 非默认文件或者需要更改规则，可通过 `options.tailwindcssSettings` 传递
282 |
283 | #### 其它
284 |
285 | - [Node.js](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/node.ts)
286 | - [Imports](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/imports.ts)
287 | - [Regexp](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/regexp.ts)
288 | - [Unicorn](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/src/configs/unicorn.ts)
289 |
290 | ## 📚 迁移指南
291 |
292 | - 扁平化配置（Flat Configs）不支持 ESLint 8.x 以下的版本。
293 | - `--ext` CLI 选项已被移除 ([#16991](https://github.com/eslint/eslint/issues/16991)) 。
294 |
295 | ## 📝 发布日志
296 |
297 | 详细更新内容请参考 [CHANGELOG](https://github.com/chengpeiquan/bassist/blob/main/packages/eslint-config/CHANGELOG.md) 。
298 |
299 | ## 📜 License
300 |
301 | MIT License © 2023-PRESENT [chengpeiquan](https://github.com/chengpeiquan)
302 |
--------------------------------------------------------------------------------
/packages/utils/src/data.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * The actual type of the data
3 | *
4 | * @category Data
5 | */
6 | export type DataType =
7 | | 'Array'
8 | | 'ArrayBuffer'
9 | | 'AsyncFunction'
10 | | 'BigInt'
11 | | 'Blob'
12 | | 'Boolean'
13 | | 'Date'
14 | | 'Error'
15 | | 'File'
16 | | 'Function'
17 | | 'Map'
18 | | 'Math'
19 | | 'Null'
20 | | 'Number'
21 | | 'Object'
22 | | 'Promise'
23 | | 'Set'
24 | | 'String'
25 | | 'Symbol'
26 | | 'RegExp'
27 | | 'Undefined'
28 | | 'WeakMap'
29 | | 'WeakSet'
30 |
31 | /**
32 | * Get the real data type
33 | *
34 | * Solve the judgment error of the value wrapped in an Object e.g. Object(1n),
35 | * Object(1)
36 | *
37 | * @category Data
38 | */
39 | export function getDataType(target: any) {
40 | return Object.prototype.toString.call(target).slice(8, -1) as DataType
41 | }
42 |
43 | /**
44 | * Wrapper for `Array.isArray`, determine whether the data is Array
45 | *
46 | * @category Data
47 | */
48 | export function isArray(value: unknown): value is any[] {
49 | return Array.isArray(value)
50 | }
51 |
52 | /**
53 | * Determine whether the data is ArrayBuffer
54 | *
55 | * @category Data
56 | */
57 | export function isArrayBuffer(value: unknown): value is ArrayBuffer {
58 | return getDataType(value) === 'ArrayBuffer'
59 | }
60 |
61 | /**
62 | * Determine whether the data is AsyncFunction
63 | *
64 | * @category Data
65 | */
66 | export function isAsyncFunction(
67 | value: unknown,
68 | ): value is (...args: any) => Promise {
69 | if (!isFunction(value)) return false
70 | return getDataType(value) === 'AsyncFunction'
71 | }
72 |
73 | /**
74 | * Determine whether the data is BigInt
75 | *
76 | * @category Data
77 | */
78 | export function isBigInt(value: unknown): value is bigint {
79 | return getDataType(value) === 'BigInt'
80 | }
81 |
82 | /**
83 | * Determine whether the data is Blob
84 | *
85 | * @category Data
86 | */
87 | export function isBlob(value: unknown): value is Blob {
88 | return getDataType(value) === 'Blob'
89 | }
90 |
91 | /**
92 | * Determine whether the data is Boolean
93 | *
94 | * @category Data
95 | */
96 | export function isBoolean(value: unknown): value is boolean {
97 | return getDataType(value) === 'Boolean'
98 | }
99 |
100 | /**
101 | * Determine whether the data is Date
102 | *
103 | * @category Data
104 | */
105 | export function isDate(value: unknown): value is Date {
106 | return getDataType(value) === 'Date'
107 | }
108 |
109 | /**
110 | * Determine whether the data is Error
111 | *
112 | * @category Data
113 | */
114 | export function isError(value: unknown): value is Error {
115 | return getDataType(value) === 'Error'
116 | }
117 |
118 | /**
119 | * Determine whether the data is Even
120 | *
121 | * @category Data
122 | */
123 | export function isEven(value: unknown): value is number {
124 | if (!isInteger(value)) return false
125 | return value % 2 === 0
126 | }
127 |
128 | /**
129 | * Determine whether the data is File
130 | *
131 | * @category Data
132 | */
133 | export function isFile(value: unknown): value is File {
134 | return getDataType(value) === 'File'
135 | }
136 |
137 | /**
138 | * Wrapper for `Number.isFinite`, determine whether the data is finite
139 | *
140 | * @category Data
141 | */
142 | export function isFinite(value: unknown): value is number {
143 | return Number.isFinite(value)
144 | }
145 |
146 | /**
147 | * Determine whether the data is Function
148 | *
149 | * @category Data
150 | */
151 | export function isFunction(value: unknown): value is (...args: any) => any {
152 | return typeof value === 'function'
153 | }
154 |
155 | /**
156 | * Wrapper for `Number.isInteger`, determine whether the data is Integer
157 | *
158 | * @category Data
159 | */
160 | export function isInteger(value: unknown): value is number {
161 | return Number.isInteger(value)
162 | }
163 |
164 | /**
165 | * Determine whether the data is Map
166 | *
167 | * @category Data
168 | */
169 | export function isMap(value: unknown): value is Map {
170 | return getDataType(value) === 'Map'
171 | }
172 |
173 | /**
174 | * Determine whether the data is Math
175 | *
176 | * @category Data
177 | */
178 | export function isMath(value: unknown): value is Math {
179 | return getDataType(value) === 'Math'
180 | }
181 |
182 | /**
183 | * Wrapper for `Number.isNaN`, determine whether the data is NaN
184 | *
185 | * @category Data
186 | */
187 | export function isNaN(value: unknown): value is number {
188 | return Number.isNaN(value)
189 | }
190 |
191 | /**
192 | * Determine whether the data is Null
193 | *
194 | * @category Data
195 | */
196 | export function isNull(value: unknown): value is null {
197 | return getDataType(value) === 'Null'
198 | }
199 |
200 | /**
201 | * Determine whether the data is Number
202 | *
203 | * @category Data
204 | */
205 | export function isNumber(value: unknown): value is number {
206 | return getDataType(value) === 'Number'
207 | }
208 |
209 | /**
210 | * Determine whether the data is Odd
211 | *
212 | * @category Data
213 | */
214 | export function isOdd(value: unknown): value is number {
215 | if (!isInteger(value)) return false
216 | return value % 2 !== 0
217 | }
218 |
219 | /**
220 | * Determine whether the data is Object
221 | *
222 | * @category Data
223 | */
224 | export function isObject(value: unknown): value is Record {
225 | return getDataType(value) === 'Object'
226 | }
227 |
228 | /**
229 | * Determine whether the data is Promise
230 | *
231 | * @category Data
232 | */
233 | export function isPromise(value: unknown): value is Promise {
234 | return getDataType(value) === 'Promise'
235 | }
236 |
237 | /**
238 | * Wrapper for `Number.isSafeInteger`, determine whether the data is Safe
239 | * Integer
240 | *
241 | * @category Data
242 | */
243 | export function isSafeInteger(value: unknown): value is number {
244 | return Number.isSafeInteger(value)
245 | }
246 |
247 | /**
248 | * Determine whether the data is Promise
249 | *
250 | * @category Data
251 | */
252 | export function isSet(value: unknown): value is Set {
253 | return getDataType(value) === 'Set'
254 | }
255 |
256 | /**
257 | * Determine whether the data is String
258 | *
259 | * @category Data
260 | */
261 | export function isString(value: unknown): value is string {
262 | return getDataType(value) === 'String'
263 | }
264 |
265 | /**
266 | * Determine whether the data is Symbol
267 | *
268 | * @category Data
269 | */
270 | export function isSymbol(value: unknown): value is symbol {
271 | return getDataType(value) === 'Symbol'
272 | }
273 |
274 | /**
275 | * Determine whether the data is Undefined
276 | *
277 | * @category Data
278 | */
279 | export function isUndefined(value: unknown): value is undefined {
280 | return getDataType(value) === 'Undefined'
281 | }
282 |
283 | /**
284 | * Determine whether the data is WeakMap
285 | *
286 | * @category Data
287 | */
288 | export function isWeakMap(value: unknown): value is WeakMap {
289 | return getDataType(value) === 'WeakMap'
290 | }
291 |
292 | /**
293 | * Determine whether the data is WeakSet
294 | *
295 | * @category Data
296 | */
297 | export function isWeakSet(value: unknown): value is WeakSet {
298 | return getDataType(value) === 'WeakSet'
299 | }
300 |
301 | /**
302 | * Determine whether the data is RegExp
303 | *
304 | * @category Data
305 | */
306 | export function isRegExp(value: unknown): value is RegExp {
307 | return getDataType(value) === 'RegExp'
308 | }
309 |
310 | /**
311 | * Determine whether the specified key exists on the object
312 | *
313 | * @category Data
314 | */
315 | export function hasKey(obj: T, key: K): key is K {
316 | if (!isObject(obj)) return false
317 | return Object.prototype.hasOwnProperty.call(obj, key)
318 | }
319 |
320 | export const hasOwnProperty = hasKey
321 |
322 | /**
323 | * String to byte stream
324 | *
325 | * @category Data
326 | */
327 | export function getBytes(value: string) {
328 | const encoder = new TextEncoder()
329 | const bytes = encoder.encode(value)
330 | return bytes
331 | }
332 |
333 | /**
334 | * @category Data
335 | */
336 | export interface InRangeOptions {
337 | num: number
338 | min: number
339 | max: number
340 | includeMin?: boolean
341 | includeMax?: boolean
342 | }
343 |
344 | /**
345 | * Checks if a number is between minimum and maximum
346 | *
347 | * @category Data
348 | */
349 | export function inRange({
350 | num,
351 | min,
352 | max,
353 | includeMin = true,
354 | includeMax = true,
355 | }: InRangeOptions) {
356 | if (!isNumber(num) || !isNumber(min) || !isNumber(max)) return false
357 |
358 | const isMin = includeMin
359 | ? num >= Math.min(min, max)
360 | : num > Math.min(min, max)
361 |
362 | const isMax = includeMax
363 | ? num <= Math.max(min, max)
364 | : num < Math.max(min, max)
365 |
366 | return isMin && isMax
367 | }
368 |
369 | /**
370 | * No operation function type
371 | *
372 | * @category Data
373 | */
374 | export type NoOperationFunction = (...args: any) => void
375 |
376 | /**
377 | * A no operation function
378 | *
379 | * @category Data
380 | */
381 | // eslint-disable-next-line @typescript-eslint/no-unused-vars
382 | export const noop: NoOperationFunction = (..._args) => void 0
383 |
384 | /**
385 | * Promisify No operation function type
386 | *
387 | * @category Data
388 | */
389 | export type PromisifyNoOperationFunction = (...args: any) => Promise
390 |
391 | /**
392 | * A promisify no operation function
393 | *
394 | * @category Data
395 | */
396 | // eslint-disable-next-line @typescript-eslint/no-unused-vars
397 | export const pnoop: PromisifyNoOperationFunction = (..._args) =>
398 | new Promise((r) => r())
399 |
--------------------------------------------------------------------------------
/packages/utils/src/format.ts:
--------------------------------------------------------------------------------
1 | import { hasKey, isArray, isObject, isString } from './data'
2 |
3 | /**
4 | * Extract numbers from text
5 | *
6 | * @category Format
7 | * @param text - Text to be processed
8 | * @param startsWithZero - Preserve the 0-starting format like `002`
9 | */
10 | export function extractNumber(text: string | number, startsWithZero = false) {
11 | text = text ? String(text) : ''
12 | text = text.replace(/[^\d]/g, '')
13 |
14 | if (text && !startsWithZero) {
15 | text = parseInt(text)
16 | }
17 |
18 | return String(text)
19 | }
20 |
21 | /**
22 | * Format amount with two decimal places
23 | *
24 | * @category Format
25 | * @param amount - Amount to be processed
26 | */
27 | export function formatAmount(amount: string | number) {
28 | amount = String(amount)
29 | if (!amount) return '0.00'
30 |
31 | const arr = amount.split('.')
32 | const integer = arr[0]
33 | const decimal = arr[1]
34 |
35 | // no decimals
36 | if (arr.length === 1) {
37 | return `${integer}.00`
38 | }
39 |
40 | // 1 decimal place
41 | if (decimal.length === 1) {
42 | return `${amount}0`
43 | }
44 |
45 | // Uniform returns two decimal places
46 | return Number(amount).toFixed(2)
47 | }
48 |
49 | /**
50 | * Add ellipses to words that are out of length
51 | *
52 | * @category Format
53 | * @param word - The sentence to be processed
54 | * @param limit - The upper limit
55 | * @returns The processed word
56 | */
57 | export function ellipsis(word: string, limit: number): string {
58 | return String(word).length > limit
59 | ? String(word).slice(0, limit) + ' ...'
60 | : String(word)
61 | }
62 |
63 | /**
64 | * Capitalize the first letter
65 | *
66 | * @category Format
67 | */
68 | export function capitalize([first, ...rest]: string) {
69 | if (!first) return ''
70 | return first.toUpperCase() + rest.join('')
71 | }
72 |
73 | /**
74 | * Formatted in `kebab-case` style
75 | *
76 | * @category Format
77 | */
78 | export function kebabCase(word: string) {
79 | if (!word) return ''
80 | return word
81 | .replace(/([A-Z])/g, ' $1')
82 | .trim()
83 | .split(' ')
84 | .join('-')
85 | .replace(/_/g, '-')
86 | .toLowerCase()
87 | }
88 |
89 | /**
90 | * Formatted in `camelCase` style
91 | *
92 | * @category Format
93 | */
94 | export function camelCase([first, ...rest]: string) {
95 | if (!first) return ''
96 | const word = first.toLowerCase() + rest.join('')
97 | return word.replace(/[-_](\w)/g, (_, c) => (c ? c.toUpperCase() : ''))
98 | }
99 |
100 | /**
101 | * Formatted in `PascalCase` style
102 | *
103 | * @category Format
104 | */
105 | export function pascalCase(word: string) {
106 | if (!word) return ''
107 | return capitalize(camelCase(word))
108 | }
109 |
110 | /**
111 | * Escaping special characters for regular expressions
112 | *
113 | * @category Format
114 | * @copyright lodash.escaperegexp
115 | */
116 | export function escapeRegExp(name: string) {
117 | const reRegExpChar = /[\\^$.*+?()[\]{}|]/g
118 | const reHasRegExpChar = RegExp(reRegExpChar.source)
119 | return name && reHasRegExpChar.test(name)
120 | ? name.replace(reRegExpChar, '\\$&')
121 | : name
122 | }
123 |
124 | /**
125 | * Sort the keys of an object
126 | *
127 | * @category Format
128 | */
129 | export function sortKeys(target: any): any {
130 | if (!Array.isArray(target) && !isObject(target)) {
131 | return target
132 | }
133 |
134 | if (Array.isArray(target)) {
135 | return target.map((i) => sortKeys(i))
136 | }
137 |
138 | const keys = Object.keys(target).sort()
139 | const newObj: Record = {}
140 | keys.forEach((k) => {
141 | newObj[k] = sortKeys(target[k])
142 | })
143 | return newObj
144 | }
145 |
146 | /**
147 | * @category Format
148 | */
149 | interface UniqueOptions {
150 | /**
151 | * The key used to determine if there are duplicate values
152 | */
153 | primaryKey: keyof T
154 |
155 | /**
156 | * He original data list
157 | */
158 | list: T[]
159 | }
160 |
161 | /**
162 | * Deduplicate an array containing objects
163 | *
164 | * @category Format
165 | */
166 | export function unique({ primaryKey, list }: UniqueOptions): T[] {
167 | // Use the value as the key and store it in the dictionary
168 | const dict: Map = new Map()
169 | list.forEach((obj) => {
170 | const value = String(obj[primaryKey])
171 | if (dict.has(value)) return
172 | dict.set(value, obj)
173 | })
174 |
175 | // Return from dictionary to array
176 | const uniqueList: T[] = []
177 | dict.forEach((value) => {
178 | uniqueList.push(value)
179 | })
180 |
181 | return uniqueList
182 | }
183 |
184 | /**
185 | * Exclude specified fields from the object
186 | *
187 | * @category Format
188 | * @param object - An object as data source
189 | * @param fields - Field names to exclude
190 | * @returns A processed new object
191 | * @tips Only handle first-level fields
192 | */
193 | export function excludeFields(object: Record, fields: string[]) {
194 | if (!isObject) return object
195 |
196 | const newObject: Record = {}
197 | for (const key in object) {
198 | if (hasKey(object, key) && !fields.includes(key)) {
199 | newObject[key] = object[key]
200 | }
201 | }
202 | return newObject
203 | }
204 |
205 | /**
206 | * Format the time as `yyyy-MM-dd HH:mm:ss`
207 | *
208 | * Note: If the date separator is `-`, it will be parsed as a standard ISO 8601
209 | * formatted date string (e.g. 2023-01-01)
210 | *
211 | * If the date separator is `/`, it will be parsed according to the non-standard
212 | * date string format (e.g. 2023/01/01 )
213 | *
214 | * This will result in inconsistent processing, please be aware of such cases.
215 | * e.g. `+new Date('2023/01/01') !== +new Date('2023-01-01')`
216 | *
217 | * @category Format
218 | * @param time - A timestamp or a date object
219 | * @param dateOnly - If `true` , only returns `yyyy-MM-dd`
220 | */
221 | export function formatTime(time: number | Date, dateOnly?: boolean) {
222 | const date = new Date(time)
223 |
224 | const year = date.getFullYear()
225 | const month = ('0' + (date.getMonth() + 1)).slice(-2)
226 | const day = ('0' + date.getDate()).slice(-2)
227 | const hours = ('0' + date.getHours()).slice(-2)
228 | const minutes = ('0' + date.getMinutes()).slice(-2)
229 | const seconds = ('0' + date.getSeconds()).slice(-2)
230 |
231 | const formattedDate = dateOnly
232 | ? `${year}-${month}-${day}`
233 | : `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
234 |
235 | return formattedDate
236 | }
237 |
238 | /**
239 | * @category Format
240 | */
241 | interface FormatDurationUnit {
242 | days: string
243 | hours: string
244 | minutes: string
245 | seconds: string
246 | }
247 |
248 | /**
249 | * Generally used to format the display of two time gaps, such as countdown
250 | *
251 | * @category Format
252 | * @param timestamp - Timestamp with two time gaps
253 | * @param units - Time units, different languages can be passed in when i18n is
254 | * needed, the default is Simplified Chinese
255 | */
256 | export function formatDuration(
257 | timestamp: number,
258 | units: FormatDurationUnit = {
259 | days: '天',
260 | hours: '小时',
261 | minutes: '分钟',
262 | seconds: '秒',
263 | },
264 | ) {
265 | // Convert timestamp to seconds
266 | const totalSeconds = Math.floor(timestamp / 1000)
267 |
268 | const days = Math.floor(totalSeconds / (3600 * 24))
269 | const hours = Math.floor((totalSeconds % (3600 * 24)) / 3600)
270 | const minutes = Math.floor((totalSeconds % 3600) / 60)
271 | const seconds = Math.floor(totalSeconds % 60)
272 |
273 | // Build a formatted string
274 | const parts: string[] = []
275 | if (days > 0) {
276 | parts.push(`${days} ${units.days}`)
277 | }
278 | if (hours > 0) {
279 | parts.push(`${hours} ${units.hours}`)
280 | }
281 | if (minutes > 0) {
282 | parts.push(`${minutes} ${units.minutes}`)
283 | }
284 | if (seconds > 0) {
285 | parts.push(`${seconds} ${units.seconds}`)
286 | }
287 |
288 | // Return the formatted result
289 | return parts.length === 0 ? `0 ${units.seconds}` : parts.join(' ')
290 | }
291 |
292 | /**
293 | * Remove HTML tags
294 | *
295 | * @category Format
296 | * @param content HTML Codes
297 | */
298 | export function removeHtmlTags(content: string) {
299 | if (!isString(content)) return ''
300 | return content.replace(/<[^<>]+>/g, '')
301 | }
302 |
303 | /**
304 | * Remove HTML tags and escape sequence
305 | *
306 | * @category Format
307 | * @param content HTML Codes
308 | */
309 | export function html2text(content: string) {
310 | if (!isString(content)) return ''
311 | return removeHtmlTags(content)
312 | .replace(/ /g, ' ')
313 | .replace(/</g, '<')
314 | .replace(/>/g, '>')
315 | .replace(/&/g, '&')
316 | .replace(/"/g, '"')
317 | .replace(/'/g, '`')
318 | .replace(/¢/g, '￠')
319 | .replace(/£/g, '£')
320 | .replace(/¥/g, '¥')
321 | .replace(/€/g, '€')
322 | .replace(/§/g, '§')
323 | .replace(/©/g, '©')
324 | .replace(/®/g, '®')
325 | .replace(/™/g, '™')
326 | .replace(/×/g, '×')
327 | .replace(/×/g, '×')
328 | .replace(/÷/g, '÷')
329 | .replace(/·/g, '·')
330 | .replace(/—/g, '—')
331 | }
332 |
333 | /**
334 | * Make sure the data you get is an array
335 | *
336 | * @category Format
337 | */
338 | export function toArray(value?: T | T[]): T[] {
339 | value = value ?? []
340 | return isArray(value) ? value : [value]
341 | }
342 |
343 | /**
344 | * Ensure prefix of a string
345 | *
346 | * @category Format
347 | */
348 | export function ensurePrefix(prefix: string, str: string) {
349 | if (!str.startsWith(prefix)) return prefix + str
350 | return str
351 | }
352 |
353 | /**
354 | * Ensure suffix of a string
355 | *
356 | * @category Format
357 | */
358 | export function ensureSuffix(suffix: string, str: string) {
359 | if (!str.endsWith(suffix)) return str + suffix
360 | return str
361 | }
362 |
--------------------------------------------------------------------------------
11 | 
