v-transform 1.1.0 → 2.0.0

package/package.json

@@ -4,13 +4,14 @@
     "vt": "src/index.js"
   },
   "type": "module",
-  "version": "1.1.0",
+  "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,8 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { readFile } from 'fs/promises';
-import { read, getWrite, jobs as getJobs } from './io.js';
-import { jobs as doJobs } from './transform/index.js';
+import { transform } from './transform.js';
 
 (async() => {
 
@@ -14,9 +13,15 @@ program
     .command('transform [list...]')
     .option('-t, --type <type>', 'type of transform, available: js, esm, cjs, json', 'json')
     .option('-s, --space <space>', 'format space number', 0)
-    .action(async (list, {type, space}) => doJobs(
-        await getJobs(list), read, getWrite(type, space),
-    ));
+    .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);
+    });
 
 program.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/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,127 +0,0 @@
-import { readFile, writeFile, stat, readdir } from 'fs/promises';
-import * as XLSX from 'xlsx';
-import { join, extname, dirname, resolve } from 'path';
-import yaml from 'js-yaml';
-
-function stringify(data, space) {
-    return JSON.stringify(data, null, space);
-}
-
-function cjs(data, space) {
-    return `module.exports = ${stringify(data, space)}`;
-}
-
-function esm(data, space) {
-    return `export default ${stringify(data, space)}`;
-}
-
-function yamlify(data, space) {
-    return yaml.dump(data, {
-        indent: space || undefined,
-    });
-}
-
-export async function read(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;
-}
-
-export function getWrite(type, space) {
-    let format, extname;
-    switch(type) {
-        case 'commonjs':
-        case 'cjs':
-            extname = '.cjs';
-            format = cjs; break;
-        case 'javascript':
-        case 'js':
-            extname = '.js';
-            format = esm; break;
-        case 'esm':
-        case 'mjs':
-            extname = '.mjs';
-            format = esm; break;
-        case 'yml':
-        case 'yaml':
-            extname = '.yaml';
-            format = yamlify; break;
-        case 'json':
-        default:
-            extname = '.json';
-            format = stringify; break;
-    }
-    return (data, target, basename) => writeFile(
-        join(target, `${basename}${extname}`),
-        format(data, Number(space)||0)
-    );
-}
-
-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;
-}
-
-export 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();
-}

package/src/transform/index.js

@@ -1,67 +0,0 @@
-import { parser } from './parser.js';
-import { merge } from './merge.js';
-
-export async function jobs(jobs, r, w) {
-    for(const { source, target } of jobs)
-        await job(source, target, r, w);
-}
-
-export 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) {
-                w(write[sheetName], target, sheetName);
-            }
-        }
-
-        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 data = merge(merges[sheetName]);
-        w(data, target, sheetName);
-    }
-}
-
-export 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.substring(
-            rawSheetName.length - 5,
-            rawSheetName.length
-        ) === "<arr>";
-        if(isArray) sheetName = sheetName.substring(0, sheetName.length - 5);
-        const isMerge = rawSheetName[0] === ">";
-        if(isMerge) sheetName = sheetName.substring(1);
-        const data = parser(rawData, isArray);
-        if(isMerge) merge[sheetName] = data;
-        else write[sheetName] = data;
-    }
-    return { merge, write };
-}

package/src/transform/merge.js

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