v-transform 2.3.3 → 3.0.1

package/package.json

@@ -4,7 +4,7 @@
     "vt": "src/index.js"
   },
   "type": "module",
-  "version": "2.3.3",
+  "version": "3.0.1",
   "main": "index.js",
   "scripts": {
     "clean": "npx rimraf test",

package/src/calibrator.js

@@ -1,27 +1,21 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { generate } from 'ts-to-zod'
+import { z } from 'zod'
 
-export async function calibrateTsData(data, name, types, pk) {
-    if (!types || !fs.existsSync(types)) {
-        console.warn(
-            `⚠️ 提示: 在 Excel 同级目录下未找到 [${name}.types.ts]，将退回普通无类型导出。`,
-        )
-        const isArray = Array.isArray(data)
-        const extra = {
-            typeSign: isArray ? 'any[]' : 'Map<any, any>',
-            types: isArray ? `export type ${name.toUpperCase()} = any;` : '',
-            isNativeMap: !isArray,
-        }
-        return { data, extra }
+export async function calibrateTsData(raw, name, dts) {
+    if (!dts || !fs.existsSync(dts)) {
+        console.warn(`⚠️ [Calibrator] ${name}.types.ts`)
+        return { raw, type: 'any', dts: '' }
     }
 
-    console.info(
-        `🔍 [vTransform TS] 成功在 Excel 目录定位规范，正在校准 [${name}]...`,
-    )
-    const sourceText = fs.readFileSync(types, 'utf-8')
-    const options = { keepOptionalProperties: true }
-    const zod = generate({ sourceText, options })
+    console.info(`🔍 [Calibrator] ${name}.types.ts`)
+    const sourceText = fs.readFileSync(dts, 'utf-8')
+    const options = {
+        keepOptionalProperties: true,
+        getSchemaName: identifier => `${identifier}Schema`,
+    }
+    const zod = generate({ sourceText, ...options })
     const tsFileBase64 = Buffer.from(sourceText).toString('base64')
     const configModule = await import(
         `data:text/javascript;base64,${tsFileBase64}`
@@ -54,111 +48,74 @@ export async function calibrateTsData(data, name, types, pk) {
         /z\.boolean\(\)/g,
         `z.preprocess(globalThis.__MERGED_TRANSFORMERS__.boolean, z.boolean())`,
     )
-    Object.keys(customTransformers).forEach(fieldKey => {
-        if (fieldKey === 'string' || fieldKey === 'boolean') return
-
-        const targetRegex = new RegExp(
-            `(${fieldKey}:\\s*)(z\\.[a-zA-Z_0-9]+(?:\\([^)]*\\))?)`,
-            'g',
-        )
-        zodRawCode = zodRawCode.replace(
-            targetRegex,
-            (m, prefix, originalZodType) => {
-                mergedTransformers[fieldKey] = customTransformers[fieldKey]
-                return `${prefix}z.preprocess(globalThis.__MERGED_TRANSFORMERS__.${fieldKey}, ${originalZodType})`
-            },
-        )
-    })
 
     globalThis.__MERGED_TRANSFORMERS__ = mergedTransformers
     const base64Code = Buffer.from(zodRawCode).toString('base64')
     const zodModule = await import(`data:text/javascript;base64,${base64Code}`)
-    delete globalThis.__MERGED_TRANSFORMERS__
-    const targetSchemaName = `${name}Schema`
-    const RowZodValidator = zodModule[targetSchemaName]
 
+    const search = `${name.replace(/[-_]/g, '')}Schema`.toLocaleLowerCase()
+    const targetSchemaName = Object.keys(zodModule).find(key => {
+        if (key.toLocaleLowerCase() === search) {
+            console.info(`🎯 [Calibrator] ${name} -> ${key}`)
+            return true
+        }
+    })
+    const RowZodValidator = zodModule[targetSchemaName]
     if (!RowZodValidator) {
-        throw new Error(
-            `无法从类型文件中自动推导出名为 ${targetSchemaName} 的主校验器。`,
-        )
+        delete globalThis.__MERGED_TRANSFORMERS__
+        throw new Error(`❌ [Calibrator] ${targetSchemaName} Missmatch`)
     }
+    const typeName = targetSchemaName.replace(/Schema$/, '')
+    dts = sourceText.split(/.*@vt-types-end.*/i)[0]
+    const data = { raw, dts, type: typeName }
+    Object.keys(customTransformers).forEach(fieldKey => {
+        if (fieldKey === 'string' || fieldKey === 'boolean') return
+        if (RowZodValidator.shape && RowZodValidator.shape[fieldKey]) {
+            const originalValidator = RowZodValidator.shape[fieldKey]
+            RowZodValidator.shape[fieldKey] = z.preprocess(
+                customTransformers[fieldKey],
+                originalValidator,
+            )
+            mergedTransformers[fieldKey] = customTransformers[fieldKey]
+        }
+    })
 
-    let cleanData
-    let typeSign = ''
-    const typeName = name.charAt(0).toUpperCase() + name.slice(1)
-
-    if (Array.isArray(data)) {
-        cleanData = []
-        typeSign = `${typeName}[]`
-        for (let i = 0; i < data.length; i++) {
-            const parseResult = RowZodValidator.safeParse(data[i])
+    globalThis.__MERGED_TRANSFORMERS__ = mergedTransformers
+    if (Array.isArray(raw)) {
+        for (let i = 0; i < raw.length; i++) {
+            const parseResult = RowZodValidator.safeParse(raw[i])
             if (!parseResult.success) {
-                printZodError(
-                    name,
-                    `第 ${i + 1} 条数据`,
-                    parseResult.error.issues,
-                    data[i],
-                )
+                delete globalThis.__MERGED_TRANSFORMERS__
+                printZodError(name, i, parseResult.error.issues, raw[i])
             }
-            cleanData.push(parseResult.data)
+            raw[i] = parseResult.data
         }
-        console.info(`📦 [Array 模式] 完美对齐数组规范`)
-    } else if (typeof data === 'object' && data !== null) {
-        const tempCleanMap = {}
-        for (const key in data) {
-            const parseResult = RowZodValidator.safeParse(data[key])
+        console.info(`✅ [Calibrator] array`)
+    } else if (typeof raw === 'object' && raw !== null) {
+        for (const key in raw) {
+            const parseResult = RowZodValidator.safeParse(raw[key])
             if (!parseResult.success) {
-                printZodError(
-                    name,
-                    `Key 为 [${key}] 的数据`,
-                    parseResult.error.issues,
-                    data[key],
-                )
-            }
-            tempCleanMap[key] = parseResult.data
-        }
-        let keyType = 'string'
-        if (pk && RowZodValidator.shape && RowZodValidator.shape[pk]) {
-            const validator = RowZodValidator.shape[pk]
-            if (
-                validator.safeParse(1).success &&
-                !validator.safeParse('1').success
-            ) {
-                keyType = 'number'
+                delete globalThis.__MERGED_TRANSFORMERS__
+                printZodError(name, key, parseResult.error.issues, raw[key])
             }
+            raw[key] = parseResult.data
         }
-
-        const isNumKey = keyType === 'number'
-        cleanData = Object.entries(tempCleanMap).map(([k, v]) => [
-            isNumKey ? Number(k) : k,
-            v,
-        ])
-        typeSign = `Map<${keyType}, ${typeName}>`
-        console.info(
-            `🎯 [Map 模式] 完美对齐原生 Map 规范，主键 [${pk}] 自动识别为: ${keyType}`,
-        )
+        console.info(`✅ [Calibrator] object`)
     }
 
-    types = sourceText.split(/.*@vt-types-end.*/i)[0]
-    const extra = { typeSign, types, isNativeMap: !Array.isArray(data) }
-    return { data: cleanData, extra }
+    delete globalThis.__MERGED_TRANSFORMERS__
+    return data
 }
 
-function printZodError(sheetName, positionLabel, issues, rawRowData) {
-    console.error(`\n❌ [vTransform 数据校准失败]`)
-    console.error(
-        `👉 发生位置: 表格 [${sheetName}] ${positionLabel}不兼容你的 TS 类型限制！`,
-    )
-    console.error(`👉 冲突细节详情:`)
+function printZodError(sheetName, key, issues, rawRowData) {
+    console.error(`❌ [Calibrator] ${sheetName}\x1b[33m[${key}]\x1b[0m`)
     issues.forEach(err => {
-        const wrongField = err.path.join('.') || '根节点'
-        console.error(`  - 错误字段: \x1b[33m${wrongField}\x1b[0m`)
-        console.error(`  - 期待类型/约束: ${err.message}`)
+        const wrongField = err.path.join('.') || 'root'
         console.error(
-            `  - 当前收到的脏数据值:`,
-            rawRowData[wrongField] ?? '缺失字段',
+            `  - \x1b[33m${wrongField}\x1b[0m:`,
+            rawRowData[wrongField],
         )
-        console.error(`  -----------------------------------------`)
+        console.error(`  - ${err.message}`)
     })
     process.exit(1)
 }

package/src/dump.js

@@ -6,43 +6,102 @@ function j(data, space) {
     return JSON.stringify(data, null, space)
 }
 
-function jsonify(name, { data, addition }, space) {
-    return j(addition ? { [name]: data, ...addition } : data, space)
+function minij(json) {
+    return json.replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)"\s*:/g, '$1:')
 }
 
-function cjsify(name, data, space) {
-    return `module.exports = ${jsonify(name, data, space)}`
+function jp(data, space) {
+    const json = j(data, space).replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+    return `JSON.parse(\n\t'${json}'\n)`
 }
 
-function esmify(name, { data, addition }, space) {
-    const main = `export const ${name} = ${jsonify(name, { data, addition }, space)}`
-    const def = `export default ${name}`
-    if (!addition) return `${main}\n${def}`
-    const extra = Object.entries(addition)
-        .map(([key, value]) => `export const ${key} = ${j(value, space)}`)
-        .join('\n')
-    return `${main}\n${extra}\n${def}`
+function map(raw, pk, space) {
+    const isArray = !pk || Array.isArray(raw)
+    if (isArray || typeof raw !== 'object') {
+        return { data: jp(raw, space), type: isArray ? 'array' : 'object' }
+    }
+    const data = Object.values(raw).map(v => [v[pk], v])
+    console.info(`🔁 [Dump] Object -> Map [${pk}]`)
+    return { data: `new Map(${jp(data, space)})`, type: 'map' }
+}
+
+function withType(main, sub, pk) {
+    switch (main) {
+        case 'array':
+            return `${sub}[]`
+        case 'map':
+            if (sub === 'any') return `Map<${sub}, ${sub}>`
+            return `Map<${sub}['${pk}'], ${sub}>`
+        case 'object':
+            return `{ [key: string]: ${sub} }`
+        default:
+            return sub
+    }
 }
 
-function yamlify(name, { data, addition }, indent) {
-    const options = { indent: indent || undefined }
-    if (!addition) return dumpYAML(data, options)
-    return dumpYAML({ [name]: data, ...addition }, options)
+function jsonify(name, data, space) {
+    const { raw, addition, dts } = data
+    const json = j(addition ? { [name]: raw, ...addition } : raw, space)
+    return [json, dts]
 }
 
-function tsify(name, { data, extra, addition }, space) {
-    const { types, typeSign, isNativeMap } = extra
-    if (!types)
-        return `export default ${jsonify(name, { data, addition }, space)}`
-    const raw = j(data, space)
-    const d = isNativeMap ? `new Map(${raw})` : raw
-    const main = `${types}\nexport const ${name} = ${d} as unknown as ${typeSign};`
-    const def = `export default ${name}`
-    if (!addition) return `${main}\n${def}`
-    const extraExports = Object.entries(addition)
-        .map(([key, value]) => `export const ${key} = ${j(value, space)}`)
-        .join('\n')
-    return `${main}\n${extraExports}\n${def}`
+function yamlify(name, data, indent) {
+    const { raw, addition, dts } = data
+    const opt = { indent: indent || undefined }
+    const yaml = dumpYAML(addition ? { [name]: raw, ...addition } : raw, opt)
+    return [yaml, dts]
+}
+
+function cjsify(name, data, space, types) {
+    const { type, pk, dts, addition } = data
+    const converted = map(data.raw, pk, space)
+    const r = []
+    if (types && dts) {
+        r.push(`/** @typedef {import('./${name}').${type}} ${type} */`)
+        r.push(`/** @type {${withType(converted.type, type, pk)}} */`)
+    }
+    r.push(`const ${name} = ${converted.data}`)
+    const exports = [name]
+    if (addition)
+        Object.entries(addition).forEach(([key, value]) => {
+            exports.push(key)
+            r.push(`const ${key} = ${j(value, space)}`)
+        })
+
+    r.push(`module.exports = { ${exports.join(', ')} }`)
+    return [r.join('\n'), dts]
+}
+
+function esmify(name, data, space, types) {
+    const { type, pk, dts, addition } = data
+    const converted = map(data.raw, pk, space)
+    const rows = []
+    if (types && dts) {
+        rows.push(`/** @typedef {import('./${name}').${type}} ${type} */`)
+        rows.push(`/** @type {${withType(converted.type, type, pk)}} */`)
+    }
+    rows.push(`export const ${name} = ${converted.data}`)
+    if (addition)
+        Object.entries(addition).forEach(([key, value]) => {
+            rows.push(`export const ${key} = ${j(value, space)}`)
+        })
+
+    rows.push(`export default ${name}`)
+    return [rows.join('\n'), dts]
+}
+
+function tsify(name, data, space) {
+    const { pk, addition } = data
+    const converted = map(data.raw, pk, space)
+    const type = withType(converted.type, data.type, pk)
+    const rows = [data.dts]
+    rows.push(`export const ${name} = ${converted.data} as unknown as ${type};`)
+    if (addition)
+        Object.entries(addition).forEach(([key, value]) =>
+            rows.push(`export const ${key} = ${j(value, space)}`),
+        )
+    rows.push(`export default ${name}`)
+    return [rows.join('\n')]
 }
 
 async function mkdirs(dir) {
@@ -58,38 +117,63 @@ async function mkdirs(dir) {
 }
 
 async function write(sheet, data) {
-    console.info(`Dump ${sheet}`)
+    console.info(`📦 -> ${sheet}`)
     await mkdirs(path.dirname(sheet))
     await writeFile(sheet, data)
 }
 
-export async function dump(sheet, data, type, space, name) {
-    let ext, ify
+export async function dump({ sheet, data, type, space, name, ext, types }) {
+    let e, ify
     switch (type) {
         case 'ts':
-            ext = '.ts'
+            e = '.ts'
             ify = tsify
             break
         case 'cjs':
-            ext = '.js'
+            e = '.js'
             ify = cjsify
             break
         case 'js':
         case 'mjs':
         case 'esm':
-            ext = '.js'
+            e = '.js'
             ify = esmify
             break
         case 'yaml':
         case 'yml':
-            ext = '.yaml'
+            e = '.yaml'
             ify = yamlify
             break
         case 'json':
         default:
-            ext = '.json'
+            e = '.json'
             ify = jsonify
             break
     }
-    return write(`${sheet}${ext}`, ify(name, data, space))
+
+    const [main, dts] = ify(name, data, space, types)
+    const result = await write(`${sheet}${ext || e}`, main)
+    if (types && dts) await write(`${sheet}.d.ts`, dts)
+
+    // if (type !== 'ts' && data?.extra?.types) {
+    //     const { types, typeSign } = data.extra
+    //     const cleanTypes = String(types).trim() + '\n'
+
+    //     const dtsLines = [
+    //         cleanTypes,
+    //         `export declare const ${name}: ${typeSign};`,
+    //         `export default ${name};`,
+    //     ]
+
+    //     if (data.addition) {
+    //         Object.entries(data.addition).forEach(([key, value]) => {
+    //             dtsLines.push(`export declare const ${key}: ${typeof value};`)
+    //         })
+    //     }
+
+    //     const dtsContent = dtsLines.join('\n') + '\n'
+    //     await write(`${sheet}.d.ts`, dtsContent)
+    // }
+
+    return result
 }

package/src/index.js

@@ -19,7 +19,9 @@ program
     .option('-w, --cwd <cwd>', 'current work dir', null)
     .option('-o, --output <output>', 'output dir', null)
     .option('-d, --dest <dest>', 'dest dir', null)
+    .option('-e, --ext <ext>', 'file ext', null)
     .option('-a, --addition', 'addition version', false)
+    .option('-x, --notypes', 'disable types generation', false)
     .action((list, options) => {
         if (!options.dest) options.dest = options.output
         options.list = list

package/src/loader.js

@@ -3,13 +3,15 @@ import { load as loadYAML } from 'js-yaml'
 import path from 'node:path'
 import { readFile } from 'node:fs/promises'
 
-export async function load({ type, space, config, dest, list, cwd, addition }) {
+export async function load(args) {
+    const { config, list, addition, ext } = args
     const version = new Date().toISOString()
-    type = type || 'json'
-    cwd = cwd || process.cwd()
-    space = Number(space) || 0
-    dest = dest || cwd
-    const def = { cwd, type, space, dest, addition }
+    const type = args.type || 'json'
+    const cwd = args.cwd || process.cwd()
+    const space = Number(args.space) || 0
+    const dest = args.dest || cwd
+    const types = !args.notypes
+    const def = { cwd, type, space, dest, addition, ext, types }
     const m = (...l) => globit(Object.assign({}, ...l))
     const cfgs = []
 

package/src/transform.js

@@ -12,26 +12,28 @@ export async function transform(options) {
     console.info(`Transformed in ${Date.now() - now}ms`)
 }
 
-async function task({ files, dest, cwd, type, space, addition }) {
-    console.info('Transform task config:', { files, dest, cwd, type, space })
+async function task(options) {
+    const { files, dest, cwd, type, space, addition, ext, types } = options
+    console.info('Transform task config:', options)
     const m = new Map()
     for (const file of files) {
         const dir = path.resolve(dest, path.dirname(file))
-        await processPrepared(path.resolve(cwd, file), dir, m, type == 'ts')
+        await processPrepared(path.resolve(cwd, file), dir, m)
     }
     for (const [sheet, job] of m) {
-        const data = await job.result()
-        await dump(sheet, { ...data, addition }, type, space, job.name)
+        const data = await job.result(addition)
+        const d = { sheet, data, type, space, name: job.name, ext, types }
+        await dump(d)
     }
 }
 
-async function processPrepared(src, dir, m, isTs) {
+async function processPrepared(src, dir, m) {
     const prepared = await prepare(src)
     const xlsxDir = path.dirname(src)
     for (const { name, data } of prepared) {
         if (name.startsWith('#')) continue
         const { sheet, keys, name: parsedName } = parseSheetAndKeys(name, dir)
-        if (!m.has(sheet)) m.set(sheet, new JobData(isTs, parsedName, xlsxDir))
+        if (!m.has(sheet)) m.set(sheet, new JobData(parsedName, xlsxDir))
         m.get(sheet).append({ keys, data: parser(data) })
     }
 }
@@ -47,15 +49,13 @@ function parseSheetAndKeys(name, dir) {
 }
 
 class JobData {
-    constructor(isTs, name, xlsxDir) {
-        this.#isTs = isTs
+    constructor(name, xlsxDir) {
         this.#name = name
         this.#xlsxDir = xlsxDir
     }
 
     #data = []
     #pk = null
-    #isTs = false
     #name = ''
     #xlsxDir = ''
 
@@ -64,8 +64,8 @@ class JobData {
         if (pk) this.#pk = pk
     }
 
-    async result() {
-        if (!this.#data.length) return {}
+    async result(addition) {
+        if (!this.#data.length) return { data: {}, extra: null }
         let result
         for (const { keys, data } of this.#data) {
             if (!keys.length) {
@@ -81,15 +81,9 @@ class JobData {
             }
             r[last] = this.#combine(r[last], data)
         }
-        if (!this.#isTs) return { data: result }
-
-        // TODO: 这里调用数据清洗
-        return await calibrateTsData(
-            result,
-            this.#name,
-            path.join(this.#xlsxDir, `${this.#name}.types.ts`),
-            this.#pk,
-        )
+        const dts = path.join(this.#xlsxDir, `${this.#name}.types.ts`)
+        const data = await calibrateTsData(result, this.#name, dts)
+        return { ...data, pk: this.#pk, addition }
     }
 
     #combine(a, b) {