v-transform 2.1.0 → 2.2.0

package/src/parser.js

@@ -1,157 +1,140 @@
-import yaml from 'js-yaml';
+import yaml from 'js-yaml'
 
-function parseStruct(head) {
-    const layer = [];
-    const subs = {};
-    const json = [];
-
-    for(const col in head) {
-        let key = head[col].trim();
-        if(key[0] == '#') continue;
-        if(key[0] == '@') {
-            json.push(col);
-            key = key.substr(1);
-        }
-        let [first, ...last] = key.split(/[\.:]/);
-        first = first.trim();
-        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;
-            }
-        }
+function isCommentKey(key) {
+    return key.startsWith('#')
+}
 
+function isJsonKey(key) {
+    return key.startsWith('@')
+}
+
+function processHeaderColumn(col, head, layer, subs, json) {
+    let key = head[col].trim()
+    if (isCommentKey(key)) return
+    if (isJsonKey(key)) {
+        json.push(col)
+        key = key.substr(1)
+    }
+    const [first, ...parts] = key.split(/[.:]/).map(p => p.trim())
+    if (!subs[first]) layer.push(first)
+    if (parts.length > 0) {
+        if (!subs[first]) subs[first] = {}
+        subs[first][col] = parts.join('.')
+    } else if (first.endsWith('[]')) {
+        if (!subs[first]) subs[first] = []
+        subs[first].push(col)
+    } else {
+        subs[first] = col
     }
+}
 
-    const struct = {
-        type: 'object',
-        subs: [],
-        json
-    };
+function createObjectSub(key, subs) {
+    subs = [parseStruct(subs[key])]
+    key = key.substr(0, key.length - 2)
+    return { type: 'object', key, 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
-                        }
-                );
-        }
-    }
+function createArraySub(key, subs) {
+    if (Array.isArray(subs[key]))
+        subs = subs[key].map(source => ({ type: 'value', source }))
+    else subs = [parseStruct(subs[key])]
+    key = key.substr(0, key.length - 2)
+    return { type: 'array', key, subs }
+}
+
+function createValueSub(key, subs) {
+    const source = subs[key]
+    if (key.startsWith('$')) key = key.substr(1)
+    return { type: 'value', key, source }
+}
 
-    return struct;
+function createNestedObjectSub(key, subs) {
+    return { type: 'object', key, subs: parseStruct(subs[key]).subs }
 }
 
-function formatRow({type, key, source, subs}, row, original, json) {
-    if(row[0] == '#' || (''+row[0])[0] == '#') return null;
-    if(key && key[0] == '#') key = row[key.substr(1)];
-    switch(type) {
+function createSubFromKey(key, subs) {
+    if (key.endsWith('{}')) return createObjectSub(key, subs)
+    if (key.endsWith('[]')) return createArraySub(key, subs)
+    if (typeof subs[key] === 'string') return createValueSub(key, subs)
+    return createNestedObjectSub(key, subs)
+}
+
+function parseStruct(head) {
+    const layer = []
+    const subs = {}
+    const json = []
+    for (const col in head) processHeaderColumn(col, head, layer, subs, json)
+    const struct = { type: 'object', subs: [], json }
+    for (const key of layer) {
+        if (key.startsWith('$')) struct.key = `#${subs[key]}`
+        const sub = createSubFromKey(key, subs)
+        struct.subs.push(sub)
+    }
+    return struct
+}
+
+function formatRow({ type, key, source, subs }, row, original, json) {
+    if (('' + row[0]).startsWith('#')) return null
+    if (key?.startsWith('#')) key = row[key.substr(1)]
+    switch (type) {
         case 'value':
-            const value = row[source];
-            if(value != void 0) {
-                try {
-                    return {
-                        key,
-                        value: json.includes(source)
-                            ? yaml.load(value)
-                            : value
-                    };
-                } catch(e) {
-                    return null;
-                }
-            }
-            return null;
+            return formatValue(key, source, row[source], json)
         case 'array':
-            const arr = original?.[key] || [];
-            for(const sub of subs) {
-                const data = formatRow(sub, row, arr, json);
-                if(data) {
-                    arr.push(data.value);
-                }
-            }
-            if(arr.length) {
-                return { key, value: arr };
-            }
-            return null;
+            return formatArray(key, subs, row, original, json)
         case 'object':
-            const obj = original?.[key] || {};
-            let r = false;
-            for(const sub of subs) {
-                const data = formatRow(sub, row, obj, json);
-                if(data) {
-                    r = true;
-                    obj[data.key] = data.value;
-                }
-            }
-            if(r) {
-                return { key, value: obj };
-            }
-            return null;
+            return formatObject(key, subs, row, original, json)
+    }
+}
+
+function formatValue(key, source, value, json) {
+    if (value == null) return null
+    if (json.includes(source)) value = yaml.load(value)
+    return { key, value }
+}
+
+function formatArray(key, subs, row, original, json) {
+    const arr = original?.[key] || []
+    for (const sub of subs) {
+        const data = formatRow(sub, row, arr, json)
+        if (data) arr.push(data.value)
+    }
+    return arr.length ? { key, value: arr } : null
+}
+
+function formatObject(key, subs, row, original, json) {
+    const obj = original?.[key] || {}
+    let hasData = false
+    for (const sub of subs) {
+        const data = formatRow(sub, row, obj, json)
+        if (data) {
+            hasData = true
+            obj[data.key] = data.value
+        }
     }
+    return hasData ? { key, value: obj } : null
 }
 
 function formatSheet(struct, rawSheet, json) {
-    let data;
-    if(struct.key == void 0) {
-        data = [];
-        for(const row of rawSheet) {
-            const temp = formatRow(struct, row, null, json);
-            if(temp) data.push(temp.value);
+    let data
+    if (struct.key == void 0) {
+        data = []
+        for (const row of rawSheet) {
+            const temp = formatRow(struct, row, null, json)
+            if (temp) data.push(temp.value)
         }
     } else {
-        data = {};
-        for(const row of rawSheet) {
-            const temp = formatRow(struct, row, data, json);
-            if(temp) data[temp.key] = temp.value;
+        data = {}
+        for (const row of rawSheet) {
+            const temp = formatRow(struct, row, data, json)
+            if (temp) data[temp.key] = temp.value
         }
     }
 
-    return data;
+    return data
 }
 
 export function parser(rawSheet) {
-    const struct = parseStruct(rawSheet.shift());
-    rawSheet.shift();
-    return formatSheet(struct, rawSheet, struct.json);
-}
+    const struct = parseStruct(rawSheet.shift())
+    rawSheet.shift()
+    return formatSheet(struct, rawSheet, struct.json)
+}

package/src/prepare.js

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

package/src/transform.js

@@ -1,91 +1,93 @@
-import path from 'path';
-import { load } from './loader.js';
-import { prepare } from './prepare.js';
-import { parser } from './parser.js';
-import { dump } from './dump.js';
+import path from 'node: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`);
+    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, addition }) {
-    console.info('Transform task config:', { files, dest, cwd, type, space });
-    const m = new Map();
+    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 = name.split('#')[0];
-            sheet = sheet.replace('<arr>', '');
-            if (sheet[0] === '>') sheet = sheet.substring(1);
-            const keys = sheet.split('.');
-            sheet = path.resolve(dir, keys.shift());
-            if (!m.has(sheet))
-                m.set(sheet, new JobData());
-            m.get(sheet).append({
-                keys, data: parser(data)
-            });
-        }
+        const dir = path.resolve(dest, path.dirname(file))
+        const prepared = await prepare(path.resolve(cwd, file))
+        processPrepared(prepared, dir, m)
     }
     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);
+        const data = job.result()
+        if (addition) await dump(sheet, { data, ...addition }, type, space)
+        else await dump(sheet, data, type, space)
+    }
+}
+
+function processPrepared(prepared, dir, m) {
+    for (const { name, data } of prepared) {
+        if (name.startsWith('#')) continue
+        const { sheet, keys } = parseSheetAndKeys(name, dir)
+        if (!m.has(sheet)) m.set(sheet, new JobData())
+        m.get(sheet).append({ keys, data: parser(data) })
     }
 }
 
+function parseSheetAndKeys(name, dir) {
+    let sheet = name.split('#')[0]
+    sheet = sheet.replace('<arr>', '')
+    if (sheet.startsWith('>')) sheet = sheet.substring(1)
+    const keys = sheet.split('.')
+    sheet = path.resolve(dir, keys.shift())
+    return { sheet, keys }
+}
+
 class JobData {
     constructor(data) {
-        if (data) this.append(data);
+        if (data) this.append(data)
     }
 
-    #data = [];
+    #data = []
 
     append(data) {
-        this.#data.push(data);
+        this.#data.push(data)
     }
 
     result() {
-        if (!this.#data.length) return {};
-        let result;
+        if (!this.#data.length) return {}
+        let result
         for (const { keys, data } of this.#data) {
             if (!keys.length) {
-                result = this.#combine(result, data);
-                continue;
+                result = this.#combine(result, data)
+                continue
             }
-            if (!result) result = {};
-            let r = result;
-            let last = keys.pop();
+            if (!result) result = {}
+            let r = result
+            let last = keys.pop()
             for (const key of keys) {
-                if (!r[key]) r[key] = {};
-                r = r[key];
+                if (!r[key]) r[key] = {}
+                r = r[key]
             }
-            r[last] = this.#combine(r[last], data);
+            r[last] = this.#combine(r[last], data)
         }
-        return result;
+        return result
     }
 
     #combine(a, b) {
-        if (a == null) return b;
-        if (b == null) return a;
+        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(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;
+        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
     }
-}
+}