v-transform 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 神戸小鳥
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# vTransform

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "v-transform",
+  "bin": {
+    "vt": "src/index.js"
+  },
+  "type": "module",
+  "version": "1.0.1",
+  "main": "index.js",
+  "repository": "https://github.com/VickScarlet/vTransform.git",
+  "author": "Vick Scarlet <scarlet_vick@outlook.com>",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^8.2.0",
+    "xlsx": "^0.17.1"
+  }
+}

package/src/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import commander from 'commander';
+import { readFile } from 'fs/promises';
+import { readXLSX, writeJSON, jobs as getJobs } from './io.js';
+import { jobs as doJobs } from './transform/index.js';
+
+commander
+    .command('version')
+    .action(async () => {
+        console.info(
+            JSON.parse(
+                    await readFile('package.json')
+                )
+                .version
+        );
+    });
+
+commander
+    .command('transform [list...]')
+    .action(async list => {
+        await doJobs(
+            await getJobs(list),
+            readXLSX,
+            writeJSON,
+        );
+    });
+
+commander
+    .name('vt');
+
+commander.parse(process.argv);

package/src/io.js

@@ -0,0 +1,88 @@
+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.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

@@ -0,0 +1,59 @@
+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) {
+                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

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

package/src/transform/parser.js

@@ -0,0 +1,142 @@
+function parseStruct(head) {
+    const layer = [];
+    const subs = {};
+
+    for(const col in head) {
+        const key = head[col];
+        if(key[0] == '#') continue;
+        const [first, ...last] = key.split(/[\.:]/);
+        if(!subs[first]) {
+            layer.push(first);
+        }
+        if(last.length > 0) {
+            if(!subs[first]) subs[first] = {};
+            subs[first][col] = last.join('.');
+        } else {
+            if(first.substr(-2) == '[]') {
+                if(!subs[first]) subs[first] = [];
+                subs[first].push(col);
+            } else {
+                subs[first] = col;
+            }
+        }
+
+    }
+
+    const struct = {
+        type: 'object',
+        subs: [],
+    };
+
+    for(const key of layer) {
+        if(key[0] == '$') {
+            struct.key = `#${subs[key]}`;
+        }
+        switch(key.substr(-2)) {
+            case '{}':
+                struct.subs.push({
+                    type: 'object',
+                    key: key.substr(0, key.length -2),
+                    subs: [ parseStruct(subs[key]) ]
+                });
+                break;
+            case '[]':
+                struct.subs.push({
+                    type: 'array',
+                    key: key.substr(0, key.length -2),
+                    subs: Array.isArray(subs[key])
+                        ? subs[key].map(col => ({
+                            type: 'value',
+                            source: col
+                        }))
+                        : [parseStruct(subs[key])]
+                });
+                break;
+            default:
+                struct.subs.push(
+                    typeof subs[key] == 'string'
+                        ? ({
+                            type: 'value',
+                            key: key[0] == '$'
+                                ? key.substr(1)
+                                : key,
+                            source: subs[key]
+                        })
+                        : {
+                            key,
+                            type: 'object',
+                            subs: parseStruct(subs[key]).subs
+                        }
+                );
+        }
+    }
+
+    return struct;
+}
+
+function formatRow({type, key, source, subs}, row, original) {
+    if(row[0] == '#' || (''+row[0])[0] == '#') return null;
+    if(key && key[0] == '#') key = row[key.substr(1)];
+    switch(type) {
+        case 'value':
+            const value = row[source];
+            if(value != void 0) {
+                return { key, value };
+            }
+            return null;
+        case 'array':
+            const arr = original?.[key] || [];
+            for(const sub of subs) {
+                const data = formatRow(sub, row, arr);
+                if(data) {
+                    arr.push(data.value);
+                }
+            }
+            if(arr.length) {
+                return { key, value: arr };
+            }
+            return null;
+        case 'object':
+            const obj = original?.[key] || {};
+            let r = false;
+            for(const sub of subs) {
+                const data = formatRow(sub, row, obj);
+                if(data) {
+                    r = true;
+                    obj[data.key] = data.value;
+                }
+            }
+            if(r) {
+                return { key, value: obj };
+            }
+            return null;
+    }
+}
+
+function formatSheet(struct, rawSheet) {
+    let data;
+    if(struct.key == void 0) {
+        const subs = struct.subs;
+        data = [];
+        for(const row of rawSheet) {
+            const temp = formatRow(struct, row);
+            if(temp) data.push(temp.value);
+        }
+    } else {
+        data = {};
+        for(const row of rawSheet) {
+            const temp = formatRow(struct, row, data);
+            if(temp) data[temp.key] = temp.value;
+        }
+    }
+
+    return data;
+}
+
+function parser(rawSheet) {
+    const struct = parseStruct(rawSheet.shift());
+    rawSheet.shift();
+    return formatSheet(struct, rawSheet);
+}
+
+export { parser };