v-transform 1.0.5 → 2.0.0

package/package.json

@@ -4,13 +4,14 @@
     "vt": "src/index.js"
   },
   "type": "module",
-  "version": "1.0.5",
+  "version": "2.0.0",
   "main": "index.js",
   "repository": "https://github.com/VickScarlet/vTransform.git",
   "author": "Vick Scarlet <scarlet_vick@outlook.com>",
   "license": "MIT",
   "dependencies": {
     "commander": "^8.2.0",
+    "glob": "^8.0.3",
     "js-yaml": "^4.1.0",
     "xlsx": "^0.17.1"
   }

package/src/dump.js

@@ -0,0 +1,63 @@
+import yaml from 'js-yaml';
+import path from 'path';
+import { writeFile, stat, mkdir } from 'fs/promises';
+
+function jsonify(data, space) {
+    return JSON.stringify(data, null, space);
+}
+
+function cjsify(data, space) {
+    return `module.exports = ${jsonify(data, space)}`;
+}
+
+function esmify(data, space) {
+    return `export default ${jsonify(data, space)}`;
+}
+
+function yamlify(data, space) {
+    return yaml.dump(data, {
+        indent: space || undefined,
+    });
+}
+
+async function mkdirs(dir) {
+    try {
+        await stat(dir);
+    } catch(e) {
+        await mkdirs(path.dirname(dir));
+        mkdir(dir);
+    }
+};
+
+async function write(sheet, data) {
+    console.info(`Dump ${sheet}`);
+    await mkdirs(path.dirname(sheet));
+    await writeFile(sheet, data);
+}
+
+export async function dump(sheet, data, type, space) {
+    let ext, ify;
+    switch(type) {
+        case 'cjs':
+            ext = '.js';
+            ify = cjsify;
+            break;
+        case 'js':
+        case 'mjs':
+        case 'esm':
+            ext = '.js';
+            ify = esmify;
+            break;
+        case 'yaml':
+        case 'yml':
+            ext = '.yaml';
+            ify = yamlify;
+            break;
+        case 'json':
+        default:
+            ext = '.json';
+            ify = jsonify;
+            break;
+    }
+    return write(`${sheet}${ext}`, ify(data, space));
+}

package/src/index.js

@@ -1,31 +1,28 @@
 #!/usr/bin/env node
-import commander from 'commander';
+import { Command } from 'commander';
 import { readFile } from 'fs/promises';
-import { readXLSX, writeJSON, jobs as getJobs } from './io.js';
-import { jobs as doJobs } from './transform/index.js';
+import { transform } from './transform.js';
 
-commander
-    .command('version')
-    .action(async () => {
-        console.info(
-            JSON.parse(
-                    await readFile('package.json')
-                )
-                .version
-        );
-    });
+(async() => {
+
+const program = new Command();
 
-commander
+program.name('vt');
+program.version(JSON.parse(await readFile('package.json')).version);
+program
     .command('transform [list...]')
-    .action(async list => {
-        await doJobs(
-            await getJobs(list),
-            readXLSX,
-            writeJSON,
-        );
+    .option('-t, --type <type>', 'type of transform, available: js, esm, cjs, json', 'json')
+    .option('-s, --space <space>', 'format space number', 0)
+    .option('-c, --config <config>', 'configure file', null)
+    .option('-w, --cwd <cwd>', 'current work dir', null)
+    .option('-o, --output <output>', 'output dir', null)
+    .option('-d, --dest <dest>', 'dest dir', null)
+    .action((list, options) => {
+        if(!options.dest) options.dest = options.output;
+        options.list = list;
+        transform(options);
     });
 
-commander
-    .name('vt');
+program.parse(process.argv);
 
-commander.parse(process.argv);
+})();

package/src/loader.js

@@ -0,0 +1,67 @@
+import glob from 'glob';
+import yaml from 'js-yaml';
+import path from 'path';
+import { readFile } from 'fs/promises';
+
+export async function load({type, space, config, dest, list, cwd}) {
+    type = type || 'json';
+    cwd = cwd || process.cwd();
+    space = Number(space) || 0;
+    dest = dest || cwd;
+    const def = {cwd, type, space, dest};
+    const m = (...l)=>globit(Object.assign({}, ...l));
+    const cfgs = [];
+
+    if(list?.length)
+        cfgs.unshift(await m(def, {glob: list}));
+
+    if(config) {
+        const c = await loadConfig(config);
+        const dir = path.dirname(config);
+        const cdef = {};
+        if(c.cwd) cdef.cwd = path.resolve(dir, c.cwd);
+        if(c.type) cdef.type = c.type;
+        if(typeof c.space == 'number') cdef.space = c.space;
+        if(c.dest) cdef.dest = path.resolve(dir, c.dest);
+        for(const cfg of c.configurations) {
+            if(cfg.cwd) cfg.cwd = path.resolve(dir, cfg.cwd);
+            if(cfg.dest) cfg.dest = path.resolve(dir, cfg.dest);
+            cfgs.push(await m(def, cdef, cfg));
+        }
+    }
+
+    return cfgs;
+}
+
+async function loadConfig(config) {
+    switch(path.extname(config)) {
+        case '.json':
+        case '.yaml':
+        case '.yml':
+            return yaml.load(
+                await readFile(config)
+            );
+        case '.js':
+        case '.mjs':
+            return (await import(config)).default;
+        default:
+            throw new Error(`Unknown config file type: ${config}`);
+    }
+}
+
+async function globit(options) {
+    const {glob: gs, cwd} = options;
+    const files = [];
+    const g = p=>new Promise(r=>glob(
+        p, {cwd}, (err, files) => r(err?[]:files)
+    ))
+    if(Array.isArray(gs))
+        for(const p of gs)
+            files.push(...await g(p));
+    else if(typeof gs == 'string')
+        files.push(...await g(gs));
+    else
+        throw new Error(`Unknown glob type: ${gs}`);
+
+    return Object.assign({files}, options);
+}

package/src/{transform/parser.js → parser.js}

@@ -91,10 +91,10 @@ function formatRow({type, key, source, subs}, row, original, json) {
             const value = row[source];
             if(value != void 0) {
                 try {
-                    return { 
-                        key, 
-                        value: json.includes(source) 
-                            ? yaml.load(value) 
+                    return {
+                        key,
+                        value: json.includes(source)
+                            ? yaml.load(value)
                             : value
                     };
                 } catch(e) {
@@ -150,10 +150,8 @@ function formatSheet(struct, rawSheet, json) {
     return data;
 }
 
-function parser(rawSheet) {
+export function parser(rawSheet) {
     const struct = parseStruct(rawSheet.shift());
     rawSheet.shift();
     return formatSheet(struct, rawSheet, struct.json);
-}
-
-export { parser };
+}

package/src/prepare.js

@@ -0,0 +1,26 @@
+import path from 'path';
+import { readFile } from 'fs/promises';
+import * as XLSX from 'xlsx';
+
+export async function prepare(xlsxPath) {
+    switch(path.extname(xlsxPath)) {
+        case '.xls':
+        case '.xlsx':
+            break;
+        default:
+            return [];
+    }
+    const xlsxFileBuffer = await readFile(xlsxPath);
+    const xlsx = XLSX.read(xlsxFileBuffer, {type: 'buffer'});
+    const sheets = xlsx.Sheets;
+    const data = [];
+    for(const sheetName in sheets) {
+        const sheetRawData = sheets[sheetName];
+        if(!sheetRawData['!ref']) break;
+        data.push({
+            name: sheetName,
+            data: XLSX.utils.sheet_to_json(sheetRawData, { header: 1 })
+        });
+    }
+    return data;
+}

package/src/transform.js

@@ -0,0 +1,60 @@
+import path from 'path';
+import { load } from './loader.js';
+import { prepare } from './prepare.js';
+import { parser } from './parser.js';
+import { dump } from './dump.js';
+
+export async function transform(options) {
+    const now = Date.now();
+    const configurations = await load(options);
+    for(const config of configurations)
+        await task(config);
+    console.info(`Transformed in ${Date.now() - now}ms`);
+}
+
+async function task({files, dest, cwd, type, space}) {
+    console.info('Transform task config:', {files, dest, cwd, type, space});
+    const m = new Map();
+    for(const file of files) {
+        const dir = path.resolve(dest, path.dirname(file));
+        for(const {name, data} of (await prepare(path.resolve(cwd, file)))) {
+            if(name[0] === "#") continue;
+            let sheet = path.resolve(dir, name.split('#')[0]);
+            if(sheet[0] === '>') sheet = sheet.substring(1)
+            sheet = sheet.replace('<arr>', '');
+            if(!m.has(sheet))
+                m.set(sheet, new JobData());
+            m.get(sheet).append(parser(data));
+        }
+    }
+    for(const [sheet, data] of m)
+        await dump(sheet, data.result(), type, space);
+}
+
+class JobData {
+    constructor(data) {
+        if(data) this.append(data);
+    }
+
+    #data = [];
+
+    append(data) {
+        this.#data.push(data);
+    }
+
+    result() {
+        if(!this.#data.length) return {};
+        const data = this.#data;
+        let result;
+        if(Array.isArray(data[0])) {
+            result = [];
+            for(const subs of data)
+                result.push(...Object.values(subs));
+        } else {
+            result = {};
+            for(const subs of data)
+                Object.assign(result, subs);
+        }
+        return result;
+    }
+}

package/src/io.js

@@ -1,88 +0,0 @@
-import { readFile, writeFile, stat, readdir } from 'fs/promises';
-import * as XLSX from 'xlsx';
-import { join, extname, dirname, resolve } from 'path';
-
-
-async function readXLSX(xlsxPath) {
-    const xlsxFileBuffer = await readFile(xlsxPath);
-    const xlsx = XLSX.read(xlsxFileBuffer, {type: 'buffer'});
-    const sheets = xlsx.Sheets;
-    const data = {};
-    for(const sheetName in sheets) {
-        const sheetRawData = sheets[sheetName];
-        if(!sheetRawData['!ref']) break;
-        data[sheetName] = XLSX.utils.sheet_to_json(sheetRawData, { header: 1 });
-    }
-    return data;
-}
-
-async function writeJSON(data, savePath) {
-    await writeFile(
-        savePath,
-        JSON.stringify(data, null, 4),
-    )
-}
-
-async function walk(filePath) {
-    const xlsxPaths = [];
-    if(Array.isArray(filePath)) {
-        for(const subPath of filePath)
-            xlsxPaths.push(await walk(subPath));
-        return xlsxPaths.flat();
-    }
-    const fileStat = await stat(filePath);
-    if(!fileStat.isDirectory()) {
-        const ext = extname(filePath);
-        if( ext=='.xls' || ext=='.xlsx' ) xlsxPaths.push(filePath);
-        return xlsxPaths;
-    }
-
-    const dirData = await readdir(filePath);
-    for(const subPath of dirData)
-        xlsxPaths.push(await walk(join(filePath, subPath)));
-    return xlsxPaths.flat();
-}
-
-async function req(config) {
-    const { configurations } = JSON.parse(await readFile(config));
-    const jobs = [];
-    const dir = dirname(config);
-    for(const { source, target } of configurations) {
-        const job = {};
-        if(Array.isArray(source)) {
-            job.source = [];
-            for(const p of source)
-                job.source.push(await walk(resolve(dir, p)))
-            job.source = job.source.flat();
-        } else {
-            job.source = await walk(resolve(dir, source));
-        }
-        job.target = resolve(dir, target);
-        jobs.push(job);
-    }
-    return jobs;
-}
-
-async function jobs(configs) {
-    const list = [];
-    const files = [];
-    for(const config of configs) {
-        switch(extname(config)) {
-            case '.json':
-                const jobs = await req(config);
-                if(jobs) list.push(jobs);
-                break;
-            default:
-                files.push(config);
-                break;
-        }
-    }
-    if(files.length > 0) {
-        const source = await walk(files);
-        const target = dirname(source[0]);
-        list.push({ source, target });
-    }
-    return list.flat();
-}
-
-export { readXLSX, writeJSON, jobs };

package/src/transform/index.js

@@ -1,69 +0,0 @@
-import { join } from 'path';
-import { parser } from './parser.js';
-import { merge } from './merge.js';
-
-async function jobs(jobs, r, w) {
-    for(const { source, target } of jobs)
-        await job(source, target, r, w);
-}
-
-async function job(source, target, r, w) {
-    const merges = {};
-    for(const xlsxPath of source) {
-        const rawData = await r(xlsxPath);
-        const { merge: mergeData, write } = transform(rawData);
-        if(write) {
-            for(const sheetName in write) {
-                const savePath = join(target, `${sheetName}.json`);
-                w(write[sheetName], savePath);
-            }
-        }
-
-        if(mergeData) {
-            for(const sheetName in mergeData) {
-                const [a, b] = sheetName.split('.');
-                if(b) {
-                    const data = {[b]: mergeData[sheetName]}
-                    if(!merges[a]) {
-                        merges[a] = [ data ];
-                    } else {
-                        merges[a].push(data);
-                    }
-                    continue;
-                }
-                if(!merges[sheetName]) {
-                    merges[sheetName] = [ mergeData[sheetName] ];
-                } else {
-                    merges[sheetName].push(mergeData[sheetName]);
-                }
-            }
-
-        }
-    }
-
-    for(const sheetName in merges) {
-        const savePath = join(target, `${sheetName}.json`);
-        const data = merge(merges[sheetName]);
-        w(data, savePath);
-    }
-}
-
-function transform(rawSheetsData) {
-    const merge = {};
-    const write = {};
-    for(const rawSheetName in rawSheetsData) {
-        const rawData = rawSheetsData[rawSheetName];
-        if(rawSheetName[0] === "#") continue;
-        let sheetName = rawSheetName;
-        const isArray = rawSheetName.substr(-5) === "<arr>";
-        if(isArray) sheetName = sheetName.substring(0, sheetName.length - 5);
-        const isMerge = rawSheetName[0] === ">";
-        if(isMerge) sheetName = sheetName.substr(1);
-        const data = parser(rawData, isArray);
-        if(isMerge) merge[sheetName] = data;
-        else write[sheetName] = data;
-    }
-    return { merge, write };
-}
-
-export { jobs, job, transform };

package/src/transform/merge.js

@@ -1,8 +0,0 @@
-function merge(datas) {
-    if(Array.isArray(datas[0]))
-        return datas.flat();
-
-    return Object.assign({}, ...datas);
-}
-
-export { merge };