All files / src/libs MarkdownBlockProcessor.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* eslint-disable no-case-declarations */
import * as yaml from 'js-yaml';
import { MarkdownPostProcessorContext } from 'obsidian';
import { ImplementsStatic } from 'src/classes/decorators/ImplementsStatic';
import { Logging } from 'src/classes/Logging';
import { IApp } from 'src/interfaces/IApp';
import IMetadataCache from 'src/interfaces/IMetadataCache';
import { IPrj } from 'src/interfaces/IPrj';
import { IPrjSettings } from 'src/types/PrjSettings';
import DocumentBlockRenderComponent from './BlockRenderComponents/DocumentBlockRenderComponent';
import HeaderBlockRenderComponent from './BlockRenderComponents/HeaderBlockRenderComponent';
import NoteBlockRenderComponent from './BlockRenderComponents/NoteBlockRenderComponent';
import ProjectBlockRenderComponent from './BlockRenderComponents/ProjectBlockRenderComponent';
import CustomizableRenderChild from './CustomizableRenderChild/CustomizableRenderChild';
import { Resolve } from './DependencyInjection/functions/Resolve';
import { HelperGeneral } from './Helper/General';
import { Lifecycle } from './LifecycleManager/decorators/Lifecycle';
import { ILifecycleObject } from './LifecycleManager/interfaces/ILifecycleObject';
import SingletonBlockProcessor from './SingletonBlockProcessor/SingletonBlockProcessor';
import { IProcessorSettings } from '../interfaces/IProcessorSettings';
 
/**
 * Class for the markdown block processor.
 */
@ImplementsStatic<ILifecycleObject>()
@Lifecycle('Static')
export default class MarkdownBlockProcessor {
    /**
     * Register the markdown block processor and update the workspace options.
     */
    public static onLoad(): void {
        Resolve<IPrj>('IPrj').registerMarkdownCodeBlockProcessor(
            'prj',
            MarkdownBlockProcessor.parseSource,
        );
 
        Resolve<IApp>('IApp').workspace.updateOptions();
    }
 
    /**
     * Parse the source of the `prj` block.
     * @param source A unique identifier for the block.
     * @param el The HTML element.
     * @param ctx The markdown post processor context.
     */
    static async parseSource(
        source: string,
        el: HTMLElement,
        ctx: MarkdownPostProcessorContext,
    ): Promise<void> {
        const startTime = Date.now();
        await Resolve<IMetadataCache>('IMetadataCache').waitForCacheReady();
        const logger = Logging.getLogger('BlockProcessor');
        logger.trace(`DocId: ${ctx.docId}`);
 
        const uid = HelperGeneral.generateUID(source.trim(), 15);
 
        const setting: IProcessorSettings = yaml.load(
            source,
        ) as IProcessorSettings;
 
        // Remove the cm-embed-block class from the parent element
        // and add the prj-block class.
        // This remove the Block-Hover-Effekt from the block
        // and with CSS we remove the Block-Edit-Button
        const parent = el.closest(
            'div.cm-preview-code-block.cm-embed-block.markdown-rendered',
        );
 
        Iif (parent) {
            parent.classList.remove('cm-embed-block');
            parent.addClass('prj-block');
        }
 
        const singletonBlockProcessor = new SingletonBlockProcessor(
            uid,
            el,
            ctx,
            Logging.getLogger('SingletonBlockProcessor'),
        );
 
        const singletonBlock = singletonBlockProcessor.singletoneContainer;
        el.append(singletonBlock);
 
        Iif (!singletonBlockProcessor.checkForSiblingBlocks()) {
            const endTime = Date.now();
 
            logger.debug(
                `MarkdownBlockProcessor runs for ${endTime - startTime}ms`,
            );
 
            return;
        }
 
        const blockContainer = document.createElement('div');
        singletonBlock.append(blockContainer);
        blockContainer.classList.add('prj-block-container');
        blockContainer.lang = Resolve<IPrjSettings>('IPrjSettings').language;
 
        Iif (setting.styles) {
            setting.styles.forEach((style) => {
                blockContainer.classList.add(style);
            });
        }
 
        const cmp = new CustomizableRenderChild(
            blockContainer,
            undefined,
            undefined,
            logger,
        );
        setting.component = cmp;
        ctx.addChild(cmp);
 
        setting.source = ctx.sourcePath;
 
        setting.frontmatter = Resolve<IMetadataCache>('IMetadataCache')
            .cache.filter((file) => file.file.path === ctx.sourcePath)
            .first()?.metadata.frontmatter;
        setting.container = blockContainer;
        setting.ctx = ctx;
 
        Iif (setting) {
            switch (setting.type) {
                case 'Documents':
                    const documentBlock = new DocumentBlockRenderComponent(
                        setting,
                    );
                    await documentBlock.build();
                    break;
                case 'Tasks':
                case 'Projects':
                case 'Topics':
                    const projectBlock = new ProjectBlockRenderComponent(
                        setting,
                    );
                    await projectBlock.build();
                    break;
                case 'Notes':
                    const noteBlock = new NoteBlockRenderComponent(setting);
                    await noteBlock.build();
                    break;
                case 'Header':
                    const header = new HeaderBlockRenderComponent(setting);
                    await header.build();
                    break;
                case 'Debug':
                    logger.debug('Debug Mode');
                    logger.debug(`Settings: ${setting}`);
                    break;
                default:
                    break;
            }
 
            const endTime = Date.now();
 
            logger.debug(
                `MarkdownBlockProcessor runs for ${endTime - startTime}ms`,
            );
        }
    }
}