@mieweb/wikigdrive/esm/src/containers/transform/MarkdownTreeProcessor.js

Google Drive to MarkDown synchronization

import process from 'node:process';
import { DirectoryScanner, RESERVED_NAMES } from './DirectoryScanner.js';
import { MimeTypes } from '../../model/GoogleFile.js';
export class MarkdownTreeProcessor {
    constructor(driveFileSystem) {
        Object.defineProperty(this, "driveFileSystem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: driveFileSystem
        });
        Object.defineProperty(this, "driveTree", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: []
        });
    }
    async load() {
        this.driveTree = await this.driveFileSystem.readJson('.tree.json') || [];
    }
    async save() {
        if (this.driveTree[0]) {
            this.driveTree[0]['wikigdrive'] = process.env.GIT_SHA;
        }
        await this.driveFileSystem.writeJson('.tree.json', this.driveTree);
    }
    async regenerateTree(rootFolderId) {
        this.driveTree = await this.internalRegenerateTree(this.driveFileSystem, rootFolderId);
    }
    async internalRegenerateTree(contentFileService, parentId) {
        const scanner = new DirectoryScanner();
        const files = await scanner.scan(contentFileService);
        const retVal = [];
        for (const realFileName in files) {
            if (RESERVED_NAMES.includes(realFileName)) {
                continue;
            }
            if (realFileName.endsWith('.debug.xml')) {
                continue;
            }
            const file = files[realFileName];
            if (file.mimeType === MimeTypes.FOLDER_MIME) {
                const subFilesService = await contentFileService.getSubFileService(realFileName);
                const item = {
                    id: file.id,
                    title: file.title,
                    path: contentFileService.getVirtualPath() + realFileName,
                    realFileName: realFileName,
                    fileName: file.fileName,
                    mimeType: file.mimeType,
                    modifiedTime: file.modifiedTime,
                    version: file.version,
                    conflicting: file.type === 'conflict' ? file.conflicting : undefined,
                    redirectTo: file.type === 'redir' ? file.redirectTo : undefined,
                    lastAuthor: 'lastAuthor' in file ? file.lastAuthor : undefined,
                    parentId,
                    children: await this.internalRegenerateTree(subFilesService, file.id)
                };
                retVal.push(item);
            }
            else {
                const item = {
                    id: file.id,
                    title: file.title,
                    path: contentFileService.getVirtualPath() + realFileName,
                    fileName: file.fileName,
                    realFileName: realFileName,
                    mimeType: file.mimeType,
                    modifiedTime: file.modifiedTime,
                    version: file.version,
                    conflicting: file.type === 'conflict' ? file.conflicting : undefined,
                    redirectTo: file.type === 'redir' ? file.redirectTo : undefined,
                    lastAuthor: 'lastAuthor' in file ? file.lastAuthor : undefined,
                    parentId
                };
                retVal.push(item);
            }
        }
        return retVal;
    }
    async findById(fileId) {
        return await this.findInTree(item => item.id === fileId, this.driveTree);
    }
    async findByPath(path) {
        return await this.findInTree(item => item.path === path, this.driveTree);
    }
    async findInTree(callBack, children, curPath = '') {
        for (const file of children) {
            const part = file['realFileName'];
            if (callBack(file)) {
                return [file, curPath ? curPath + '/' + part : part];
            }
        }
        for (const file of children) {
            if (file.mimeType !== MimeTypes.FOLDER_MIME) {
                continue;
            }
            if (file.children) {
                const part = file['realFileName'];
                const tuple = await this.findInTree(callBack, file.children, curPath ? curPath + '/' + part : part);
                if (tuple?.length > 0) {
                    return tuple;
                }
            }
        }
        return [];
    }
    async walkTree(callBack) {
        await this.findInTree(callBack, this.driveTree);
    }
    async getRootItem(driveId) {
        return [{
                path: '/',
                fileName: '/',
                realFileName: '/',
                title: '/',
                mimeType: MimeTypes.FOLDER_MIME,
                id: driveId,
                parentId: driveId,
                children: this.driveTree
            }, '/'];
    }
    isEmpty() {
        return this.driveTree.length === 0;
    }
    getTree() {
        return this.driveTree;
    }
    getTreeVersion() {
        if (this.driveTree.length < 1) {
            return null;
        }
        return this.driveTree[0]['wikigdrive'] || null;
    }
}