v-transform 2.0.2 → 2.1.0

package/package.json

@@ -4,14 +4,17 @@
     "vt": "src/index.js"
   },
   "type": "module",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "main": "index.js",
   "scripts": {
     "clean": "npx rimraf test",
     "vt": "node src/index.js",
     "transform": "node src/index.js transform"
   },
-  "repository": "https://github.com/VickScarlet/vTransform.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VickScarlet/vTransform.git"
+  },
   "author": "Vick Scarlet <scarlet_vick@outlook.com>",
   "license": "MIT",
   "dependencies": {

package/src/index.js

@@ -3,26 +3,27 @@ import { Command } from 'commander';
 import { readFile } from 'fs/promises';
 import { transform } from './transform.js';
 
-(async() => {
+(async () => {
 
-const program = new Command();
+    const program = new Command();
 
-program.name('vt');
-program.version(JSON.parse(await readFile('package.json')).version);
-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)
-    .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.name('vt');
+    program.version(JSON.parse(await readFile('package.json')).version);
+    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)
+        .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)
+        .option('-a, --addition', 'addition version', false)
+        .action((list, options) => {
+            if (!options.dest) options.dest = options.output;
+            options.list = list;
+            transform(options);
+        });
 
-program.parse(process.argv);
+    program.parse(process.argv);
 
 })();

package/src/loader.js

@@ -3,38 +3,43 @@ import yaml from 'js-yaml';
 import path from 'path';
 import { readFile } from 'fs/promises';
 
-export async function load({type, space, config, dest, list, cwd}) {
+export async function load({ type, space, config, dest, list, cwd, addition }) {
+    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};
-    const m = (...l)=>globit(Object.assign({}, ...l));
+    const def = { cwd, type, space, dest, addition };
+    const m = (...l) => globit(Object.assign({}, ...l));
     const cfgs = [];
 
-    if(list?.length)
-        cfgs.unshift(await m(def, {glob: list}));
+    if (list?.length)
+        cfgs.unshift(await m(def, { glob: list }));
 
-    if(config) {
+    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);
+        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));
         }
     }
 
+    for (const cfg of cfgs)
+        if (cfg.addition)
+            cfg.addition = { version, timestamp: version }
+
     return cfgs;
 }
 
 async function loadConfig(config) {
-    switch(path.extname(config)) {
+    switch (path.extname(config)) {
         case '.json':
         case '.yaml':
         case '.yml':
@@ -50,18 +55,18 @@ async function loadConfig(config) {
 }
 
 async function globit(options) {
-    const {glob: gs, cwd} = options;
+    const { glob: gs, cwd } = options;
     const files = [];
-    const g = p=>new Promise(r=>glob(
-        p, {cwd}, (err, files) => r(err?[]:files)
+    const g = p => new Promise(r => glob(
+        p, { cwd }, (err, files) => r(err ? [] : files)
     ))
-    if(Array.isArray(gs))
-        for(const p of gs)
+    if (Array.isArray(gs))
+        for (const p of gs)
             files.push(...await g(p));
-    else if(typeof gs == 'string')
+    else if (typeof gs == 'string')
         files.push(...await g(gs));
     else
         throw new Error(`Unknown glob type: ${gs}`);
 
-    return Object.assign({files}, options);
+    return Object.assign({ files }, options);
 }

package/src/transform.js

@@ -7,37 +7,42 @@ import { dump } from './dump.js';
 export async function transform(options) {
     const now = Date.now();
     const configurations = await load(options);
-    for(const config of configurations)
+    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});
+async function task({ files, dest, cwd, type, space, addition }) {
+    console.info('Transform task config:', { files, dest, cwd, type, space });
     const m = new Map();
-    for(const file of files) {
+    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;
+        for (const { name, data } of (await prepare(path.resolve(cwd, file)))) {
+            if (name[0] === "#") continue;
             let sheet = name.split('#')[0];
             sheet = sheet.replace('<arr>', '');
-            if(sheet[0] === '>') sheet = sheet.substring(1);
+            if (sheet[0] === '>') sheet = sheet.substring(1);
             const keys = sheet.split('.');
             sheet = path.resolve(dir, keys.shift());
-            if(!m.has(sheet))
+            if (!m.has(sheet))
                 m.set(sheet, new JobData());
             m.get(sheet).append({
                 keys, data: parser(data)
             });
         }
     }
-    for(const [sheet, data] of m)
-        await dump(sheet, data.result(), type, space);
+    for (const [sheet, job] of m) {
+        const data = job.result();
+        if (addition)
+            await dump(sheet, { data, ...addition }, type, space);
+        else
+            await dump(sheet, data, type, space);
+    }
 }
 
 class JobData {
     constructor(data) {
-        if(data) this.append(data);
+        if (data) this.append(data);
     }
 
     #data = [];
@@ -47,28 +52,40 @@ class JobData {
     }
 
     result() {
-        if(!this.#data.length) return {};
-        const d = this.#data;
+        if (!this.#data.length) return {};
         let result;
-        if(Array.isArray(d[0].data)) {
-            result = [];
-            for(const {data} of d)
-                result.push(...Object.values(data));
-        } else {
-            result = {};
-            for(const {keys, data} of d) {
-                if(!keys.length) {
-                    Object.assign(result, data);
-                    continue;
-                }
-                let r = result;
-                for(const key of keys) {
-                    if(!r[key]) r[key] = {};
-                    r = r[key];
-                }
-                Object.assign(r, data);
+        for (const { keys, data } of this.#data) {
+            if (!keys.length) {
+                result = this.#combine(result, data);
+                continue;
+            }
+            if (!result) result = {};
+            let r = result;
+            let last = keys.pop();
+            for (const key of keys) {
+                if (!r[key]) r[key] = {};
+                r = r[key];
             }
+            r[last] = this.#combine(r[last], data);
+        }
+        return result;
+    }
+
+    #combine(a, b) {
+        if (a == null) return b;
+        if (b == null) return a;
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (Array.isArray(b)) return a.concat(b);
+            a.push(b);
+            return a;
         }
+        if (Array.isArray(a))
+            return this.#combine(a, Object.values(b));
+        if (Array.isArray(b))
+            return this.#combine(Object.values(a), b);
+        const result = {};
+        for (const key in a) result[key] = this.#combine(a[key], b[key]);
+        for (const key in b) if (!result[key]) result[key] = b[key];
         return result;
     }
 }