diff --git a/README_RU.md b/README_RU.md
new file mode 100644
index 000000000..bb219e0ba
--- /dev/null
+++ b/README_RU.md
@@ -0,0 +1,82 @@
+# Yank Note
+
+**Гибкий, расширяемый** редактор Markdown, создан для повышения производительности. **[Скачать](https://github.com/purocean/yn/releases)** | **[Попробовать онлайн >>>](https://demo.yank-note.com/)**
+
+
+[](https://apps.apple.com/cn/app/yank-note/id1551528618) [Не рекомендуется](https://github.com/purocean/yn/issues/65#issuecomment-1065799677)
+
+[English](./README.md) | [中文说明](./README_ZH-CN.md) | Русский
+
+[toc]{level: [2]}
+
+
+
+## Особенности
+
+- **Простота использования:** Используется ядро *Monaco*, оптимизированное для редактирования в формате Markdown, и возможности редактирования такие же, как у VSCode.
+- **Мощный:** Поддержка контроля версий; в документ можно встраивать апплеты, запускаемые блоки кода, таблицы, PlantUML, Drawio, макрозамены и т.д.; поддержка автодополнения AI Copilot.
+- **Высокая совместимость:** Данные сохраняются в виде локальных файлов Markdown, а функции расширения реализованы в оригинальном синтаксисе Markdown, насколько это возможно.
+- **Расширение плагинов:** Поддержка пользователей в написании собственных плагинов для расширения функциональности редактора.
+- **Поддержка шифрования:** Используйте шифрование для сохранения приватных файлов, таких как номер счета, а пароль может быть установлен отдельно для каждого файла.
+
+## Внимание
+
+- Ради большей расширяемости Yank Note жертвует защитой безопасности (выполнение команд, произвольное чтение и запись файлов). Если вы хотите использовать его для открытия постороннего файла Markdown, ⚠️**убедитесь, что содержимое файла заслуживает доверия**⚠️.
+- Шифрование и дешифрование зашифрованных файлов выполняется на клиентской стороне. Пожалуйста, **убедитесь, что вы помните свой пароль**. Если пароль утерян, его можно только взломать.
+
+## Основнве функции
+
+Более подробную информацию об использовании следующих функций см. в разделе [описание основных функций](./help/FEATURES.md)
+
+- **Синхронная прокрутка:** область редактирования и область предварительного просмотра прокручиваются синхронно, а область предварительного просмотра можно прокручивать независимо
+- **Конспект:** быстрый переход к соответствующему месту документа через конспект в области предварительного просмотра
+- **Управление версиями:** поддержка истории документа
+- **Шифрование:** файлы, заканчивающиеся на `.c.md`, обрабатываются как зашифрованные
+- **Автосохранение:** автоматическое сохранение файлов после редактирования с напоминанием в строке заголовка для несохраненных файлов (зашифрованные документы не сохраняются автоматически)
+- **Редактирование:** автоматическое заполнение списка
+- **Вставка изображений:** вы можете быстро вставлять изображения из буфера обмена и вставлять их как файлы или Base64
+- **Вложения:** вы можете добавлять вложения в документ и открывать их в операционной системе щелчком мыши
+- **Выполнение кода:** поддержка запуска JavaScript, PHP, nodejs, Python, кода bash
+- **Список задач:** поддержка отображения хода выполнения задач в документе. Щелкните, чтобы быстро переключить статус задачи
+- **Быстрое открытие:** вы можете использовать сочетание клавиш для открытия панели переключения файлов, чтобы быстро открывать файлы, помеченные файлы и выполнять полнотекстовый поиск по содержимому файлов
+- **Интегрированный терминал:** поддержка открытия терминала в редакторе для быстрого переключения текущего рабочего каталога
+- **LaTeX:** поддержка выражений LaTeX
+- **Стили:** Markdown использует стили и функции GitHub
+- **Репозиторий:** можно определить несколько расположений данных для организации документов
+- **Преобразование внешних ссылок:** преобразование внешних ссылок или изображений Base64 в локальные изображения
+- **Разрешение HTML:** вы можете использовать HTML-код непосредственно в документе или использовать сочетания клавиш для копирования и вставки HTML в Markdown
+- **Экспорт в несколько форматов:** backend использует pandoc в качестве конвертера
+- **TOC:** напишите `[toc]{type:** "ol", level:** [1,2,3]}` для генерации TOC (Table Of Content, оглавление), где вам нужно сгенерировать его
+- **Изменить ячейку таблицы:** дважды щелкните ячейку таблицы для быстрого редактирования
+- **Копирование ссылки на заголовок:** копирование пути ссылки на заголовок в буфер обмена для легкой вставки в другие файлы
+- **Встроенные апплеты:** документ поддерживает встроенные HTML-аплеты
+- **Встроенная графика PlantUML:** документ поддерживает встроенную графику plantUML
+- **Встроенная графика drawio:** документ поддерживает встроенную графику drawio
+- **Встроенная графика ECharts:** документ поддерживает встроенную графику Echarts
+- **Встроенная графика Mermaid:** документ поддерживает встроенную графику Mermaid
+- **Встроенные таблицы Luckysheet:** документ поддерживает встроенные таблицы Luckysheet
+- **Mind map:** вложенный список может быть отображен в виде интеллект-карты
+- **Запись атрибутов элемента:** любой атрибут элемента может быть настроен
+- **Улучшение таблиц:** поддержка заголовка таблицы с несколькими строками текста, списка и других функций
+- **Ссылка на документ:** поддержка ссылок на другие документы в документе и перехода друг к другу
+- **Сноска:** поддержка написания сносок в документе
+- **Пользовательский контейнер:** поддержка пользовательских контейнеров, аналогичных VuePress по умолчанию темы
+- **Макросы:** поддержка встроенных выражений JavaScript для динамической замены содержимого документа
+- **Служба хостинга изображений:** поддержка службы хостинга изображений [PicGo](https://picgo.github.io/PicGo-Doc/)
+- **OpenAI:** поддержка автодополнения [OpenAI](https://openai.com)
+- **Пользовательские плагины:** поддержка написания плагинов JavaScript для расширения функциональности редактора. Плагин находится в `home directory/plugins`. См. [руководство по разработке плагинов](./help/PLUGIN.md)
+
+## Скриншоты
+
+
+
+
+
+
+
+
+## Поддержка
+
+Wechat Group
+
+
diff --git a/commitlint.config.js b/commitlint.config.js
new file mode 100644
index 000000000..84dcb122a
--- /dev/null
+++ b/commitlint.config.js
@@ -0,0 +1,3 @@
+module.exports = {
+ extends: ['@commitlint/config-conventional'],
+};
diff --git a/electron-builder.json b/electron-builder.json
index b6fa77f8d..3683fb08f 100644
--- a/electron-builder.json
+++ b/electron-builder.json
@@ -7,13 +7,15 @@
"bin/**/*",
"help/**/*",
"dist/main/resources/**/*",
- "node_modules/plantuml-pipe/**/*",
- "node_modules/node-pty/**/*"
+ "node_modules/fsevents/**/*",
+ "node_modules/node-pty/**/*",
+ "node_modules/@vscode/ripgrep/**/*"
],
"files": [
"./bin/**",
"./help/**",
- "./dist/**"
+ "./dist/**",
+ "!node_modules/plantuml-pipe/vendor/*"
],
"artifactName": "Yank-Note-${os}-${arch}-${version}.${ext}",
"directories": {
@@ -33,7 +35,8 @@
"maintainer": "purocean
+
+
+ {{$t('doc-history.history')}}
+ {{$t('doc-history.current')}}
+
+
+
+
+
+
+
diff --git a/src/renderer/__tests__/core/hook.ts b/src/renderer/__tests__/core/hook.ts
new file mode 100644
index 000000000..6522f1899
--- /dev/null
+++ b/src/renderer/__tests__/core/hook.ts
@@ -0,0 +1,117 @@
+import * as hook from '@fe/core/hook'
+import * as ioc from '@fe/core/ioc'
+
+jest.mock('@fe/support/args', () => ({
+ FLAG_DEMO: false,
+}))
+
+jest.mock('@fe/utils', () => ({
+ getLogger: () => new Proxy({}, { get: () => () => 0 })
+}))
+
+afterEach(() => {
+ ioc.removeAll('ACTION_AFTER_RUN')
+})
+
+test('hook usage 1', async () => {
+ const fn1 = jest.fn()
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ const res = await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' })
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(res).toBe(undefined)
+})
+
+test('hook usage 2', async () => {
+ const fn1 = jest.fn().mockReturnValue(true)
+ const fn2 = jest.fn().mockReturnValue(true)
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' })
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(fn2).toHaveBeenCalledWith({ name: 'test' })
+})
+
+test('hook usage 3', async () => {
+ const fn1 = jest.fn().mockReturnValue(true)
+ const fn2 = jest.fn().mockReturnValue(true)
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ const res = await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true })
+ expect(res).toBe(true)
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(fn2).toBeCalledTimes(0)
+})
+
+test('hook usage 4', async () => {
+ const fn1 = jest.fn().mockReturnValue(Promise.resolve(true))
+ const fn2 = jest.fn().mockReturnValue(true)
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ const res = await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true })
+ expect(res).toBe(true)
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(fn2).toBeCalledTimes(0)
+})
+
+test('hook usage 5', async () => {
+ const fn1 = jest.fn().mockReturnValue(false)
+ const fn2 = jest.fn().mockReturnValue(true)
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ const res = await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true })
+ expect(res).toBe(true)
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(fn2).toHaveBeenCalledWith({ name: 'test' })
+})
+
+test('hook usage 6', async () => {
+ const fn1 = jest.fn().mockReturnValue(Promise.resolve(false))
+ const fn2 = jest.fn().mockReturnValue(true)
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ const res = await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true })
+ expect(res).toBe(true)
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(fn2).toHaveBeenCalledWith({ name: 'test' })
+})
+
+test('hook usage 7', async () => {
+ const fn1 = jest.fn().mockReturnValue(Promise.resolve(false))
+ const fn2 = jest.fn().mockReturnValue(false)
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ const res = await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true })
+ expect(res).toBe(false)
+ expect(fn1).toHaveBeenCalledWith({ name: 'test' })
+ expect(fn2).toHaveBeenCalledWith({ name: 'test' })
+})
+
+test('hook usage 8', async () => {
+ const fn1 = jest.fn()
+ hook.registerHook('ACTION_AFTER_RUN', fn1)
+ await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' })
+ await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' })
+ expect(fn1).toBeCalledTimes(2)
+})
+
+test('hook usage 8', async () => {
+ const fn1: any = jest.fn()
+ hook.registerHook('ACTION_BEFORE_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn1, true)
+ await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' })
+ await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' })
+ await hook.triggerHook('ACTION_BEFORE_RUN', { name: 'test' })
+ await hook.triggerHook('ACTION_BEFORE_RUN', { name: 'test' })
+ expect(fn1).toBeCalledTimes(3)
+})
+
+test('hook usage 9', async () => {
+ const fn1 = () => { throw new Error('test') }
+ const fn2 = () => Promise.reject(new Error('test'))
+ hook.registerHook('ACTION_BEFORE_RUN', fn1)
+ hook.registerHook('ACTION_AFTER_RUN', fn2)
+ await hook.triggerHook('ACTION_BEFORE_RUN', { name: 'test' }, { ignoreError: true })
+ await hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true, ignoreError: true })
+ await expect(hook.triggerHook('ACTION_BEFORE_RUN', { name: 'test' })).rejects.toThrow()
+ await expect(hook.triggerHook('ACTION_AFTER_RUN', { name: 'test' }, { breakable: true })).rejects.toThrow()
+})
diff --git a/src/renderer/__tests__/core/ioc.ts b/src/renderer/__tests__/core/ioc.ts
new file mode 100644
index 000000000..8d1a9d326
--- /dev/null
+++ b/src/renderer/__tests__/core/ioc.ts
@@ -0,0 +1,72 @@
+import * as ioc from '@fe/core/ioc'
+
+test('ioc usage', () => {
+ expect(ioc.get('ACTION_AFTER_RUN')).toEqual([])
+ ioc.remove('ACTION_AFTER_RUN', null)
+ ioc.register('ACTION_AFTER_RUN', 'test')
+ ioc.register('ACTION_AFTER_RUN', 'test1')
+ expect(ioc.get('ACTION_AFTER_RUN')).toEqual(['test', 'test1'])
+ ioc.remove('ACTION_AFTER_RUN', 'test2')
+ expect(ioc.get('ACTION_AFTER_RUN')).toEqual(['test', 'test1'])
+ ioc.remove('ACTION_AFTER_RUN', 'test')
+ expect(ioc.get('ACTION_AFTER_RUN')).toEqual(['test1'])
+ ioc.removeAll('ACTION_AFTER_RUN')
+
+ ioc.register('ACTION_AFTER_RUN', 'test')
+ ioc.register('ACTION_AFTER_RUN', 'test1')
+ ioc.register('ACTION_AFTER_RUN', 'test2')
+ ioc.register('ACTION_AFTER_RUN', 'test3')
+ ioc.register('ACTION_AFTER_RUN', 'test4')
+
+ ioc.removeWhen('ACTION_AFTER_RUN', item => item === 'test' || item === 'test3')
+ expect(ioc.get('ACTION_AFTER_RUN')).toEqual(['test1', 'test2', 'test4'])
+
+ ioc.removeAll('ACTION_AFTER_RUN')
+ ioc.register('ACTION_AFTER_RUN', 'test')
+ ioc.register('ACTION_AFTER_RUN', 'test1')
+ ioc.register('ACTION_AFTER_RUN', 'test2')
+ ioc.register('ACTION_AFTER_RUN', 'test3')
+ ioc.register('ACTION_AFTER_RUN', 'test4')
+
+ for (const item of ioc.get('ACTION_AFTER_RUN')) {
+ ioc.remove('ACTION_AFTER_RUN', item)
+ }
+
+ expect(ioc.get('ACTION_AFTER_RUN')).toEqual([])
+
+ // test getRaw
+ expect(ioc.getRaw('ACTION_AFTER_RUN_XXX' as any) === undefined)
+ ioc.register('ACTION_AFTER_RUN', 'test1')
+ const content1 = ioc.get('ACTION_AFTER_RUN')
+ const raw1 = ioc.getRaw('ACTION_AFTER_RUN')
+ ioc.register('ACTION_AFTER_RUN', 'test2')
+ const content2 = ioc.get('ACTION_AFTER_RUN')
+ const raw2 = ioc.getRaw('ACTION_AFTER_RUN')
+ expect(content1 === content2).toBe(false)
+ expect(raw1 === raw2).toBe(true)
+ expect(content1).toEqual(['test1'])
+ expect(content2).toEqual(['test1', 'test2'])
+ expect([...raw1!]).toEqual(['test1', 'test2'])
+ expect([...raw2!]).toEqual(['test1', 'test2'])
+ ioc.removeAll('ACTION_AFTER_RUN')
+ expect(raw1 === raw2).toBe(true)
+ expect(raw1?.length).toEqual(0)
+
+ // test version
+ expect(ioc.getRaw('ACTION_BEFORE_RUN') === undefined).toBe(true)
+ ioc.register('ACTION_BEFORE_RUN', 'test1')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(1)
+ ioc.register('ACTION_BEFORE_RUN', 'test2')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(2)
+ ioc.register('ACTION_BEFORE_RUN', 'test3')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(3)
+ ioc.remove('ACTION_BEFORE_RUN', 'test1')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(4)
+ ioc.removeWhen('ACTION_BEFORE_RUN', item => item === 'test2')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(5)
+ ioc.removeAll('ACTION_BEFORE_RUN')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(6)
+ ioc.register('ACTION_BEFORE_RUN', 'test1')
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version).toBe(7)
+ expect(ioc.getRaw('ACTION_BEFORE_RUN')?._version === undefined).toBe(false)
+})
diff --git a/src/renderer/__tests__/core/plugin.ts b/src/renderer/__tests__/core/plugin.ts
new file mode 100644
index 000000000..2d34219dd
--- /dev/null
+++ b/src/renderer/__tests__/core/plugin.ts
@@ -0,0 +1,29 @@
+import * as plugin from '@fe/core/plugin'
+
+jest.mock('@fe/utils', () => ({
+ getLogger: () => new Proxy({}, { get: () => () => 0 })
+}))
+
+test('plugin usage', () => {
+ const fn = jest.fn()
+ plugin.register({
+ name: 'test',
+ register: fn,
+ }, 123)
+
+ expect(fn).toHaveBeenCalledWith(123)
+
+ plugin.register({
+ name: 'test',
+ register: fn,
+ }, 123)
+
+ expect(fn).toHaveBeenCalledTimes(1)
+
+ plugin.register({
+ name: 'test2',
+ register: () => '12345',
+ }, 123)
+
+ expect(plugin.getApi('test2')).toBe('12345')
+})
diff --git a/src/renderer/__tests__/others/extension.ts b/src/renderer/__tests__/others/extension.ts
new file mode 100644
index 000000000..89c8e15a0
--- /dev/null
+++ b/src/renderer/__tests__/others/extension.ts
@@ -0,0 +1,184 @@
+import * as extension from '@fe/others/extension'
+
+jest.mock('@fe/support/api', () => ({}))
+jest.mock('@fe/services/theme', () => ({}))
+jest.mock('@fe/services/view', () => ({}))
+jest.mock('js-untar', () => ({}))
+jest.mock('@fe/support/args', () => ({
+ FLAG_DEMO: false,
+}))
+
+jest.mock('@fe/utils', () => ({
+ getLogger: console.log
+}))
+
+jest.mock('@fe/services/i18n', () => ({
+ getCurrentLanguage: () => 'zh-CN'
+}))
+
+jest.mock('@fe/core/action', () => ({
+ getActionHandler: () => () => 0
+}))
+
+;(global as any).__APP_VERSION__ = '3.29.0'
+
+test('readInfoFromJson', () => {
+ expect(extension.readInfoFromJson(undefined)).toBeNull()
+ expect(extension.readInfoFromJson({})).toBeNull()
+ expect(extension.readInfoFromJson({ name: 'test' })).toBeNull()
+
+ expect(extension.readInfoFromJson({ name: 'test', version: '1.1.2' })).toStrictEqual({
+ id: 'test',
+ author: { name: '' },
+ displayName: 'test',
+ main: '',
+ style: '',
+ description: '',
+ version: '1.1.2',
+ themes: [],
+ origin: 'unknown',
+ dist: { tarball: '', unpackedSize: 0 },
+ icon: '',
+ homepage: '',
+ license: '',
+ readmeUrl: '',
+ changelogUrl: '',
+ compatible: {
+ reason: 'Not yank note extension.',
+ value: false,
+ },
+ requirements: {},
+ })
+
+ expect(extension.readInfoFromJson({
+ name: 'test',
+ version: '1.1.2',
+ license: 'MIT',
+ engines: {
+ 'yank-note': '>=3.29.0',
+ },
+ })).toStrictEqual({
+ id: 'test',
+ author: { name: '' },
+ displayName: 'test',
+ main: '',
+ style: '',
+ description: '',
+ version: '1.1.2',
+ themes: [],
+ origin: 'unknown',
+ dist: { tarball: '', unpackedSize: 0 },
+ icon: '',
+ homepage: '',
+ license: 'MIT',
+ compatible: {
+ reason: 'Compatible',
+ value: true,
+ },
+ readmeUrl: '',
+ changelogUrl: '',
+ requirements: {},
+ })
+
+ expect(extension.readInfoFromJson({
+ name: 'test',
+ version: '1.1.2',
+ engines: {
+ 'yank-note': '>=3.30.0',
+ },
+ requirements: { premium: true, terminal: false }
+ })).toStrictEqual({
+ id: 'test',
+ author: { name: '' },
+ displayName: 'test',
+ main: '',
+ style: '',
+ description: '',
+ version: '1.1.2',
+ themes: [],
+ origin: 'unknown',
+ dist: { tarball: '', unpackedSize: 0 },
+ icon: '',
+ homepage: '',
+ license: '',
+ requirements: { premium: true, terminal: false },
+ compatible: {
+ reason: 'Need Yank Note [>=3.30.0].',
+ value: false,
+ },
+ readmeUrl: '',
+ changelogUrl: '',
+ })
+
+ expect(extension.readInfoFromJson({
+ name: 'test',
+ author: 'test
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/DefaultEditor.vue b/src/renderer/components/DefaultEditor.vue
new file mode 100644
index 000000000..cd2ecf0d5
--- /dev/null
+++ b/src/renderer/components/DefaultEditor.vue
@@ -0,0 +1,162 @@
+
+
+
+
+
+ {{ category.displayName }}
+
+
+
+
+
+ {{ item.displayName }}
+ ({{ item.extension.join(',') }})
+
+
+ {{ $t('document.current-path', currentPath) }}
+
+
+
+
+
+
+
diff --git a/src/renderer/components/DefaultPreviewer.vue b/src/renderer/components/DefaultPreviewer.vue
new file mode 100644
index 000000000..0d5a2e1e9
--- /dev/null
+++ b/src/renderer/components/DefaultPreviewer.vue
@@ -0,0 +1,465 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/DefaultPreviewerRender.ce.vue b/src/renderer/components/DefaultPreviewerRender.ce.vue
new file mode 100644
index 000000000..cf7434705
--- /dev/null
+++ b/src/renderer/components/DefaultPreviewerRender.ce.vue
@@ -0,0 +1,540 @@
+
+
+
+
+
+
+
+
+
+ TOP
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/DocHistory.vue b/src/renderer/components/DocHistory.vue
new file mode 100644
index 000000000..031eb5861
--- /dev/null
+++ b/src/renderer/components/DocHistory.vue
@@ -0,0 +1,596 @@
+
+
+
+
+
+
+
+
+ {{$t('doc-history.clear')}}({{sizeText}})
+
+
+
+
+
+ {{i.toString().padStart(4, '0')}}
+ {{version.label}}
+
+
+
+
+ {{version.comment}}
+ No Message
+
+
+
+ {{$t('loading')}}
+ {{$t('doc-history.no-history')}}
+ {{currentVersion?.label}} {{currentVersion?.title}} {{currentDoc.name}}
+
+
+
+
+
+
-
+
+
+ {{$t('export-panel.export')}}
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ DEV-{{ item.displayName }}
+ {{ item.displayName }}
+
+ {{ item.version }}
+ {{ $t('extension.upgradable') }}
+
+ {{ item.description }}
+
+
+
+
+
+
+ {{ $t('extension.incompatible') }}
+ {{ $t('extension.not-installed') }}
+
+
+ {{ `${item.activationTime.toFixed(2)}ms` }}
+
+ {{ $t('extension.enabled') }}
+
+ {{ $t('extension.disabled') }}
+ {{ $t('extension.reload-required') }}
+
+
+ {{ $t('loading') }}
+ {{ $t('extension.no-extension') }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ DEV-{{ currentExtension.displayName }}
+ {{ currentExtension.displayName }}
+
+ {{ currentExtension.id }}@{{ currentExtension.version }}
+ {{ $t('extension.upgradable') }} {{ currentExtension.latestVersion }}
+
+
+
+
+ {{ $t('extension.origin') }}
+ {{ $t('extension.unknown') }}
+
+
+ {{ $t('extension.author') }}
+
+
+
+ {{ $t('extension.latest-version') }}
+ {{ currentExtension.latestVersion }}
+
+
+ {{ $t('extension.unpacked-size') }}
+ {{ (currentExtension.dist.unpackedSize / 1048576).toFixed(2) }}MiB
+ {{ (currentExtension.dist.unpackedSize / 1024).toFixed(2) }}KiB
+
+
+ {{ $t('extension.homepage') }}
+ {{ currentExtension.homepage.split('/')[2] }}
+
+
+ License
+ {{ currentExtension.license }}
+
+
+ ![npm]()
+
+
+ {{ $t('extension.requirement') }}
+ {{ $t('premium.premium') }}
+
+
+ {{ $t('extension.requirement') }}
+ Terminal
+
+ {{ currentExtension.description }}
+
+ {{ $t('extension.installing') }} {{installing}}
+
+
+ {{ $t('extension.uninstalling') }}
+
+
+
+ {{ $t('extension.reload-required') }}
+
+
+
+
+
+
+
+
+
+
+
+ {{currentExtension.compatible.reason}}
+ {{currentExtension.newVersionCompatible?.reason}}
+
+
+
+
+
+ {{ $t('loading') }}
+
+
+
+
+
+ {{ $t('loading') }}
+
+ {{ $t('extension.extension-manager') }}
+
+
+
+ {{$t('extension.registry')}}:
+
+
+
+
+
+ {{ $t('extension.reload-required') }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/IndexStatus.vue b/src/renderer/components/IndexStatus.vue
new file mode 100644
index 000000000..1403cc99d
--- /dev/null
+++ b/src/renderer/components/IndexStatus.vue
@@ -0,0 +1,149 @@
+
+ {{tab.label}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/KeyboardShortcuts.vue b/src/renderer/components/KeyboardShortcuts.vue
new file mode 100644
index 000000000..2a031f9ad
--- /dev/null
+++ b/src/renderer/components/KeyboardShortcuts.vue
@@ -0,0 +1,557 @@
+
+ + [{{ currentRepo.name }}] {{ $t('index-status.indexing') }} +
+ +[{{ currentRepo.name }}] {{ $t('index-status.indexing') }} ({{ currentRepoIndexStatus.indexed }}) ({{ currentRepoIndexStatus.cost }}ms)
+{{ currentRepoIndexStatus.processing }}
+ + + ++ {{ $t('index-status.indexed') }} {{ currentRepoIndexStatus?.indexed }} ({{ currentRepoIndexStatus?.cost }}ms) +
+
+
+
+
+
+
+
+
+ | # | +{{ $t('keyboard-shortcuts.command') }} | +{{ $t('keyboard-shortcuts.keybinding') }} | ++ | |
|---|---|---|---|---|
{{ i + 1 }} |
+
+ {{ item.description }}
+ {{ item.command }} |
+ + {{ key }} + {{ t('keyboard-shortcuts.not-set') }} + + {{ t('keyboard-shortcuts.conflict') }} + + | ++ + {{ $t('keyboard-shortcuts.clear') }} + | ++ {{ $t('keyboard-shortcuts.change') }} + {{ $t('keyboard-shortcuts.clear') }} + {{ $t('keyboard-shortcuts.reset') }} + | +
| + {{ $t('keyboard-shortcuts.empty') }} + | +||||
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/Layout.vue b/src/renderer/components/Layout.vue
index 6f7ff6887..6915d7493 100644
--- a/src/renderer/components/Layout.vue
+++ b/src/renderer/components/Layout.vue
@@ -1,26 +1,29 @@
- {{ $t('keyboard-shortcuts.recorder.tip') }}
+
+
+ {{ getKeysLabel(shortcuts) }}
+
+
+ {{ $t('keyboard-shortcuts.recorder.conflict-commands', String(conflictCommands.length)) }}
+
+
-
+
+
-
-
-
+
@@ -31,30 +34,73 @@
-
diff --git a/src/renderer/components/ModalUi.vue b/src/renderer/components/ModalUi.vue
index 7ff359267..43469a76b 100644
--- a/src/renderer/components/ModalUi.vue
+++ b/src/renderer/components/ModalUi.vue
@@ -1,40 +1,53 @@
-
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/Premium.vue b/src/renderer/components/Premium.vue
new file mode 100644
index 000000000..1a1dbe615
--- /dev/null
+++ b/src/renderer/components/Premium.vue
@@ -0,0 +1,649 @@
+
+
+
+
+
+
+
+
diff --git a/src/renderer/components/Preview.vue b/src/renderer/components/Preview.vue
deleted file mode 100644
index 5d94ccf71..000000000
--- a/src/renderer/components/Preview.vue
+++ /dev/null
@@ -1,516 +0,0 @@
-
-
+
+
+
+
+
+
diff --git a/src/renderer/components/QuickOpen.vue b/src/renderer/components/QuickOpen.vue
index 7c9fa7029..5876a0fcd 100644
--- a/src/renderer/components/QuickOpen.vue
+++ b/src/renderer/components/QuickOpen.vue
@@ -1,85 +1,122 @@
-
{{title}}
-{{content}}
+{{content}}
- - + +
-
-
+
+
++ {{$t('premium.premium')}} + +
+
+
+
+
+ {{$t('premium.intro.desc')}}
+
+
+
+
+
+
+
+
+ {{$t('premium.free')}}
+{{$t('premium.intro.free-desc')}}
+ -
+
- {{item}} +
+
+
+
+
+
+
+
+
+ {{$t('premium.premium')}}
+{{$t('premium.intro.premium-desc')}}
+ -
+
- {{item}} +
+
+
+
+ {{$t('premium.activation.need-refresh')}}
+ Refreshing...
+
+
+
+ {{$t('premium.activation.expired')}}
+
+ Refreshing...
+
+
+
+ {{$t('premium.activation.need-refresh')}}
+ Refreshing...
+
+
+
+ {{$t('premium.activation.expiring', String(tokenAvailableDays(info)))}}
+
+ Refreshing...
+
+
+
+
+
+
+
+
+ {{$t('premium.activation.info')}}
+-
+
- {{$t('premium.activation.name', info.name)}} +
- {{$t('premium.activation.email', info.email)}} +
- {{$t('premium.activation.plan', info.displayName)}} +
- {{$t('premium.activation.expires', info.expires.toLocaleDateString())}} +
+
+ {{$t('premium.activation.devices')}} ({{devices.length}})
+-
+
- + {{device.label}} + {{$t('premium.activation.unbind')}} + +
+ Machine Code
+ {{ $t('premium.activation.online-activation') }}
+
+
+
+
+
+
+ Activation Token
+ {{ $t('premium.activation.get-activation-token') }}
+ ![]()
+
+
+
+
+
+ {{ $t('premium.activation.placeholder') }}
+
+ {{ $t('premium.activation.offline-activation') }} |
+ {{ $t('premium.activation.get-license') }}
+
+
+
+
+
+ {{$t('premium.activation.tips')}}:
+ yank-note@outlook.com
+ |
+ {{$t('premium.activation.tips-wechat')}}
+ 
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/renderer/components/Previewer.vue b/src/renderer/components/Previewer.vue
new file mode 100644
index 000000000..eb5d67ccd
--- /dev/null
+++ b/src/renderer/components/Previewer.vue
@@ -0,0 +1,79 @@
+
+
-
- 目录
-
-
-
- {{ head.text }}
- {{head.tag}}
-
- TOP
-
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
diff --git a/src/renderer/components/Setting.vue b/src/renderer/components/Setting.vue
index 868666706..cdf24894d 100644
--- a/src/renderer/components/Setting.vue
+++ b/src/renderer/components/Setting.vue
@@ -1,92 +1,126 @@
{{tab.label}}
+
+
diff --git a/src/renderer/components/SearchPanel.vue b/src/renderer/components/SearchPanel.vue
new file mode 100644
index 000000000..30daeb009
--- /dev/null
+++ b/src/renderer/components/SearchPanel.vue
@@ -0,0 +1,1220 @@
+
+
+
-
+
{{tab.label}}
-
-
- 加载中…… +
- {{$t('loading')}}
- - + {{item.name}} - - [{{item.repo}}] {{item.path.substr(0, item.path.lastIndexOf('/'))}} + + [{{item.repo}}] + {{item.path.slice(0, item.path.lastIndexOf('/'))}} + + -
- 无结果 +
- {{$t('quick-open.empty')}}
+
+
+
+
+
+ {{$t(isReplaceVisible ? 'search-panel.replace-files' : 'search-panel.search-files')}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{$t('search-panel.files-to-include')}}
+
+ {{$t('search-panel.files-to-exclude')}}
+
+
+
+
+
+
+
+
+
+ {{basename(item.path)}}
+ {{dirname(item.path)}}
+
+ {{item.numMatches}}
+
+
+
+
+
+ {{fragment.value}}
+
+
-
diff --git a/src/renderer/components/SettingPanel.vue b/src/renderer/components/SettingPanel.vue
index 72e14b368..d0e669528 100644
--- a/src/renderer/components/SettingPanel.vue
+++ b/src/renderer/components/SettingPanel.vue
@@ -5,19 +5,20 @@
@@ -42,26 +26,15 @@ export default defineComponent({
.status-bar {
box-sizing: border-box;
- padding: 0 1em;
+ padding: 0;
color: #eee;
- background: #4e4e4e;
+ background: #38383a;
font-size: 12px;
line-height: 20px;
height: 100%;
display: flex;
justify-content: space-between;
-}
-
-.document-info {
- white-space: nowrap;
overflow: hidden;
- text-overflow: ellipsis;
- margin-right: 0.3em;
-}
-
-.document-info > span {
- display: inline-block;
- padding: 0 .2em;
}
.action {
diff --git a/src/renderer/components/StatusBarMenu.vue b/src/renderer/components/StatusBarMenu.vue
index addac80c4..3bdab4281 100644
--- a/src/renderer/components/StatusBarMenu.vue
+++ b/src/renderer/components/StatusBarMenu.vue
@@ -1,25 +1,42 @@
- 配置项
- +{{$t('setting-panel.setting')}}
+
+
-
-
diff --git a/src/renderer/components/SvgIcon.vue b/src/renderer/components/SvgIcon.vue
index ccd64d7ef..0106d42b6 100644
--- a/src/renderer/components/SvgIcon.vue
+++ b/src/renderer/components/SvgIcon.vue
@@ -1,9 +1,68 @@
-
+
diff --git a/src/renderer/components/TitleBar.vue b/src/renderer/components/TitleBar.vue
index ad42a975f..2ecdb0b53 100644
--- a/src/renderer/components/TitleBar.vue
+++ b/src/renderer/components/TitleBar.vue
@@ -9,19 +9,19 @@
{{statusText}}
+
+
+ {{menu.title}}
-
-
- {{item.title}} +
-
+
+ + +
+
-
+
+
+
-
+
+
-
+
-
+
-
+
@@ -30,22 +30,21 @@
-
diff --git a/src/renderer/components/TreeNode.vue b/src/renderer/components/TreeNode.vue
index f7bebcd07..28949d274 100644
--- a/src/renderer/components/TreeNode.vue
+++ b/src/renderer/components/TreeNode.vue
@@ -1,185 +1,350 @@
-
+
-
-
-
- {{ item.name === '/' ? currentRepoName : item.name }} ({{item.children.length}})
+ :style="`padding-left: ${itemNode.level}em`"
+ @contextmenu.exact.prevent.stop="showContextMenu(itemNode)">
+
+
+ {{ itemNode.name }} ({{itemNode.children ? itemNode.children.length : 0}})
- ;
+}
+
+db.version(1).stores({
+ documents: '++id, repo, [repo+path]',
+})
+
+export const documents = {
+ getTable () {
+ return db.documents
+ },
+ findByRepoAndPath (repo: string, path: string): Promise {
+ logger.debug('getByRepoAndPath', repo, path)
+ return db.documents.where({ repo, path }).first()
+ },
+ async findAllMtimeMsByRepo (repo: string): Promise> {
+ logger.debug('findAllMtimeMsByRepo', repo)
+ const map = new Map()
+ await db.documents.where({ repo }).each(doc => {
+ map.set(doc.path, { id: doc.id, mtimeMs: doc.mtimeMs })
+ })
+ return map
+ },
+ put (entity: Omit & { id?: number }): Promise {
+ logger.debug('updateOrInsert', entity)
+ return db.documents.put(entity)
+ },
+ bulkPut (items: (Omit & { id?: number })[]): Promise {
+ logger.debug('blukPut', items.length)
+ return db.documents.bulkPut(items, { allKeys: true })
+ },
+ async deleteByRepo (repo: string): Promise {
+ logger.debug('deleteByRepo', repo)
+ const deleted = await db.documents.where({ repo }).delete()
+ logger.debug('deleteByRepo deleted', deleted)
+ return deleted
+ },
+ async deleteUnusedRepo (usedRepos: string[]): Promise {
+ logger.debug('deleteUnusedRepo', usedRepos)
+ const deleted = await db.documents.where('repo').noneOf(usedRepos).delete()
+ logger.debug('deleteUnusedRepo deleted', deleted)
+ return deleted
+ },
+ async deleteUnusedInRepo (repo: string, usedIds: number[]): Promise {
+ logger.debug('deleteUnusedInRepo', repo, usedIds.length)
+ const allIds = await db.documents.where({ repo }).primaryKeys()
+ const toDeleteIds = difference(allIds, usedIds)
+ await db.documents.bulkDelete(toDeleteIds)
+ logger.debug('deleteUnusedInRepo deleted', toDeleteIds.length)
+ return toDeleteIds.length
+ },
+ async deletedByRepoAndPath (repo: string, path: string): Promise {
+ logger.debug('deletedByRepoAndPath', repo, path)
+ const deleted = await db.documents.where({ repo, path }).delete()
+ logger.debug('deletedByRepoAndPath deleted', deleted)
+ return deleted
+ }
+}
+
+export async function removeOldDatabases () {
+ const databases = await Dexie.getDatabaseNames()
+ const oldDatabases = databases.filter(name => name.startsWith(dbPrefix) && name !== dbName)
+ logger.debug('remove old databases', oldDatabases)
+ oldDatabases.forEach(name => Dexie.delete(name))
+}
diff --git a/src/renderer/others/demo.ts b/src/renderer/others/demo.ts
new file mode 100644
index 000000000..a4924e7ea
--- /dev/null
+++ b/src/renderer/others/demo.ts
@@ -0,0 +1,364 @@
+import { setTheme } from '@fe/services/theme'
+import * as storage from '@fe/utils/storage'
+import { FLAG_DEMO } from '@fe/support/args'
+import { useToast } from '@fe/support/ui/toast'
+import { getRenderIframe } from '@fe/services/view'
+import { t } from '@fe/services/i18n'
+
+let settings = {
+ repositories: { test: '/path_test' },
+ shell: 'bash',
+ mark: [
+ { repo: 'test', path: '/TODO.md' }
+ ]
+}
+
+const treeData = {
+ status: 'ok',
+ message: 'success',
+ data: [
+ {
+ name: '/',
+ type: 'dir',
+ path: '/',
+ repo: 'test',
+ level: 1,
+ children: [
+ { name: 'Work', path: '/Work', type: 'dir', repo: 'test', level: 2, children: [{ name: '1.md', path: '/Work/1.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635402958.447, mtime: 1623635402958.447 }, { name: '2.md', path: '/Work/2.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635406528.4639, mtime: 1623635406528.4639 }, { name: '3.md', path: '/Work/3.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635410176.051, mtime: 1623635410177.0498 }] },
+ { name: 'Learn', path: '/Learn', type: 'dir', repo: 'test', level: 2, children: [{ name: 'a.md', path: '/Learn/a.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635423871.2678, mtime: 1623635423871.2678 }, { name: 'b.md', path: '/Learn/b.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635427472.3079, mtime: 1623635427472.3079 }, { name: 'c.md', path: '/Learn/c.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635431935.041, mtime: 1623635431935.041 }] },
+ { name: 'TEST.md', path: '/TEST.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635389096.3315, mtime: 1623635389097.3403 },
+ { name: 'TODO.md', path: '/TODO.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635437968.1262, mtime: 1623635437969.1235 },
+ { name: 'Secret.c.md', path: '/Secret.c.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Project.luckysheet', path: '/Project.luckysheet', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Drawio.drawio', path: '/Drawio.drawio', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Reveal-js.md', path: '/Reveal-js.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Markmap.md', path: '/Markmap.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ ]
+ }]
+}
+
+const markupContent = `---
+defaultPreviewer: 'Markmap'
+---
+
+# markmap
+
+## Links
+
+- 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 ()
+
+export const registries: RegistryHostname[] = [
+ 'registry.npmjs.org',
+ 'registry.npmmirror.com',
+]
+
+function shouldLoad (extension: Extension) {
+ return extension.enabled && extension.compatible
+}
+
+function changeRegistryOrigin (hostname: RegistryHostname, url: string) {
+ const _url = new URL(url)
+ _url.hostname = hostname
+ return _url.toString()
+}
+
+export function getExtensionPath (id: string, ...paths: string[]) {
+ return path.join(id.replace(/\//g, '$'), ...paths)
+}
+
+export function getInstalledExtensionFileUrl (id: string, filename: string) {
+ if (/https?:\/\//.test(filename)) {
+ return filename
+ }
+
+ return path.join('/extensions', getExtensionPath(id, filename))
+}
+
+export function getLoadStatus (id: string): ExtensionLoadStatus {
+ return loaded.get(id) || { version: undefined, themes: false, plugin: false, style: false, activationTime: 0 }
+}
+
+export function getCompatible (engines?: { 'yank-note': string }): ExtensionCompatible {
+ if (!engines || !engines['yank-note']) {
+ return { value: false, reason: 'Not yank note extension.' }
+ }
+
+ const engineVersion = __APP_VERSION__
+
+ const value = semver.satisfies(engineVersion, engines['yank-note'])
+
+ return {
+ value,
+ reason: value ? 'Compatible' : `Need Yank Note [${engines['yank-note']}].`,
+ }
+}
+
+export function readInfoFromJson (json: any): Omit | null {
+ if (!json || !json.name || !json.version) {
+ return null
+ }
+
+ const language = i18n.getCurrentLanguage().toUpperCase()
+
+ return {
+ id: json.name,
+ version: json.version,
+ license: typeof json.license === 'string' ? json.license : '',
+ author: typeof json.author === 'string'
+ ? parseAuthor(json.author) || { name: '' }
+ : json.author || { name: '' },
+ themes: json.themes || [],
+ requirements: json.requirements || {},
+ main: json.main || '',
+ style: json.style || '',
+ icon: json.icon || '',
+ readmeUrl: json.readmeUrl || '',
+ changelogUrl: json.changelogUrl || '',
+ displayName: json[`displayName_${language}`] || json.displayName || json.name,
+ description: json[`description_${language}`] || json.description || '',
+ compatible: getCompatible(json.engines),
+ origin: json.origin || 'unknown',
+ dist: json.dist || { tarball: '', unpackedSize: 0 },
+ homepage: json.homepage || '',
+ }
+}
+
+export async function getInstalledExtension (id: string): Promise {
+ let json
+
+ try {
+ json = await api.fetchHttp(getInstalledExtensionFileUrl(id, 'package.json'))
+ if (!json.name || !json.version) {
+ throw new Error('Invalid extension package.json')
+ }
+ } catch (error) {
+ logger.error(error)
+ return null
+ }
+
+ const info = readInfoFromJson(json)
+ if (info) {
+ return { ...info, installed: true, origin: FLAG_DEMO ? 'registry' : 'unknown' }
+ }
+
+ return null
+}
+
+export async function getInstalledExtensions () {
+ const extensions: Extension[] = []
+ for (const item of await api.fetchInstalledExtensions()) {
+ const info = await getInstalledExtension(item.id)
+ if (info) {
+ if (info.id !== item.id) {
+ logger.warn(`Extension ${item.id} has been installed but package.json is not valid.`)
+ continue
+ }
+
+ extensions.push({
+ ...info,
+ installed: true,
+ enabled: item.enabled && info.compatible.value,
+ icon: getInstalledExtensionFileUrl(info.id, info.icon),
+ readmeUrl: getInstalledExtensionFileUrl(info.id, 'README.md'),
+ changelogUrl: getInstalledExtensionFileUrl(info.id, 'CHANGELOG.md'),
+ isDev: item.isDev,
+ })
+ }
+ }
+
+ return extensions
+}
+
+export async function getRegistryExtensions (registry: RegistryHostname = 'registry.npmjs.org'): Promise {
+ logger.debug('getRegistryExtensions', registry)
+
+ const registryUrl = `https://${registry}/yank-note-registry`
+ const registryJson = await api.proxyFetch(registryUrl, { timeout: 5000 }).then(r => r.json())
+ const latest = registryJson['dist-tags'].latest
+ const tarballUrl = changeRegistryOrigin(registry, registryJson.versions[latest].dist.tarball)
+
+ const extensions = await api.proxyFetch(tarballUrl, { timeout: 5000 })
+ .then(r => r.arrayBuffer())
+ .then(data => pako.inflate(new Uint8Array(data)))
+ .then(arr => arr.buffer)
+ .then(buffer => untar(buffer))
+ .then(files => files.find((x: any) => x.name === 'package/index.json'))
+ .then(file => new TextDecoder('utf-8').decode(file.buffer))
+ .then(JSON.parse)
+
+ return extensions.map(readInfoFromJson)
+}
+
+export function showManager (id?: string) {
+ getActionHandler('extension.show-manager')(id)
+}
+
+export async function enable (extension: Extension) {
+ await api.enableExtension(extension.id)
+ extension.enabled = true
+ await load(extension)
+ triggerHook('EXTENSION_READY', { extensions: [extension] })
+}
+
+export async function disable (extension: Pick) {
+ await api.disableExtension(extension.id)
+}
+
+export async function uninstall (extension: Pick) {
+ await api.uninstallExtension(extension.id)
+}
+
+export async function abortInstallation () {
+ await api.abortExtensionInstallation()
+}
+
+export async function install (extension: Extension, registry: RegistryHostname = 'registry.npmjs.org') {
+ const url = extension.dist.tarball
+ if (!url) {
+ throw new Error('No dist url')
+ }
+
+ await api.installExtension(extension.id, changeRegistryOrigin(registry, url))
+ await enable(extension)
+}
+
+async function load (extension: Extension) {
+ if (shouldLoad(extension)) {
+ logger.debug('load', extension.id)
+ const loadStatus: ExtensionLoadStatus = loaded.get(extension.id) || { themes: false, plugin: false, style: false, activationTime: 0 }
+
+ loadStatus.version = extension.version
+
+ let scriptStartTime = performance.now()
+ let scriptEndTime = scriptStartTime
+ let pluginPromise: Promise | undefined
+
+ const main = extension?.main
+ if (!loadStatus.plugin && main && (main.endsWith('.js') || main.endsWith('.mjs'))) {
+ pluginPromise = new Promise((resolve, reject) => {
+ const script = window.document.createElement('script')
+ script.src = getInstalledExtensionFileUrl(extension.id, main)
+ script.defer = true
+
+ // support esm
+ if (main.endsWith('.mjs')) {
+ script.type = 'module'
+ }
+
+ script.onload = () => {
+ resolve()
+ scriptEndTime = performance.now()
+ script.onload = null
+ }
+
+ script.onerror = (error) => {
+ reject(error)
+ scriptEndTime = performance.now()
+ script.onerror = null
+ }
+
+ window.document.body.appendChild(script)
+ setTimeout(() => {
+ scriptStartTime = performance.now()
+ }, 0)
+ })
+ }
+
+ const style = extension?.style
+ if (!loadStatus.style && style && style.endsWith('.css')) {
+ const href = getInstalledExtensionFileUrl(extension.id, style)
+
+ // add style to workbench
+ theme.addStyleLink(href)
+
+ // also add style to preview iframe
+ view.addStyleLink(href)
+
+ loadStatus.style = true
+ }
+
+ if (!loadStatus.themes && extension?.themes && extension.themes.length) {
+ extension.themes.forEach(style => {
+ theme.registerThemeStyle({
+ from: 'extension',
+ name: `[${extension.id}]: ${style.name}`,
+ css: `extension:${getExtensionPath(extension.id, style.css)}`,
+ })
+ })
+ loadStatus.themes = true
+ }
+
+ if (pluginPromise) {
+ try {
+ await pluginPromise
+ } catch (error) {
+ console.warn(`Load extension error [${extension.id}]`, error)
+ } finally {
+ loadStatus.plugin = true
+ loadStatus.activationTime = scriptEndTime - scriptStartTime
+ }
+ }
+
+ loaded.set(extension.id, loadStatus)
+ }
+}
+
+let initialized = false
+
+export function getInitialized () {
+ return initialized
+}
+
+export function whenInitialized (): Promise {
+ return new Promise(resolve => {
+ if (initialized) {
+ resolve()
+ } else {
+ registerHook('EXTENSION_READY', () => {
+ resolve()
+ }, true)
+ }
+ })
+}
+
+/**
+ * Initialization extension system
+ */
+export async function init () {
+ logger.debug('init')
+
+ const extensions = (await getInstalledExtensions()).filter(shouldLoad)
+
+ for (const extension of extensions) {
+ await load(extension)
+ }
+
+ initialized = true
+ triggerHook('EXTENSION_READY', { extensions })
+}
diff --git a/src/renderer/support/extensions.ts b/src/renderer/others/file-extensions.ts
similarity index 86%
rename from src/renderer/support/extensions.ts
rename to src/renderer/others/file-extensions.ts
index 03ea8dbf8..fa7c8a1af 100644
--- a/src/renderer/support/extensions.ts
+++ b/src/renderer/others/file-extensions.ts
@@ -48,6 +48,8 @@ const extensions = [
'.java',
'.jav',
'.js',
+ '.mjs',
+ '.cjs',
'.es6',
'.jsx',
'.kt',
@@ -112,6 +114,8 @@ const extensions = [
'.swift',
'.tcl',
'.ts',
+ '.mts',
+ '.cts',
'.tsx',
'.vb',
'.xml',
@@ -141,11 +145,19 @@ const extensions = [
'.azcli',
'.cls',
'.graphql',
- '.gql'
+ '.gql',
+ '.bib',
+ '.plantuml',
+ '.dot',
+ '.gv',
+ '.puml',
+ '.lrc',
]
const supported = (name: string) => {
- return extensions.includes(extname(name.toLowerCase()))
+ name = name.toLowerCase()
+ const ext = extname(name) || (name.startsWith('.') ? name : '')
+ return ext ? extensions.includes(ext) : false
}
export default {
diff --git a/src/renderer/others/find-in-preview.ts b/src/renderer/others/find-in-preview.ts
new file mode 100644
index 000000000..3ca594c5e
--- /dev/null
+++ b/src/renderer/others/find-in-preview.ts
@@ -0,0 +1,122 @@
+import { escapeRegExp } from 'lodash-es'
+
+interface Opts {
+ caseSensitive?: boolean;
+ regex?: boolean;
+}
+
+export interface IFindInPreview {
+ exec(pattern: string, opts: Opts): void;
+ getStats(): { count: number, current: number }
+ next(): boolean;
+ prev(): boolean;
+}
+
+export class BrowserFindInPreview implements IFindInPreview {
+ private _matchCount = 0
+ private _win: Window
+ private _maxMatchCount: number
+ private _maxMatchTime: number
+ private _wrapAround = false
+ private _matches: string[] = []
+ private _currentMatchIndex = 0
+ private _opts: Opts = {}
+ private _pattern = ''
+ private _exceed = false
+
+ constructor (win: Window, opts?: { maxMatchCount?: number, maxMatchTime?: number, wrapAround?: boolean }) {
+ this._win = win
+ this._maxMatchCount = opts?.maxMatchCount || 3000
+ this._maxMatchTime = opts?.maxMatchTime || 3000
+ this._wrapAround = !!opts?.wrapAround
+ }
+
+ exec (pattern: string, opts: Opts) {
+ this._opts = opts
+ this._pattern = pattern
+ this._matchCount = 0
+ this._currentMatchIndex = 0
+ this._matches = []
+ this._exceed = false
+
+ if (!pattern) {
+ return
+ }
+
+ const { caseSensitive, regex } = opts
+ const flags = caseSensitive ? 'g' : 'gi'
+ const re = regex ? new RegExp(pattern, flags) : new RegExp(escapeRegExp(pattern), flags)
+ // innerText will not return the text of hidden elements, and strip out tags while preserving newlines.
+ const content = this._win.document.body.innerText
+
+ const startTime = Date.now()
+ let match
+ while ((match = re.exec(content))) {
+ if (Date.now() - startTime > this._maxMatchTime) {
+ console.warn(`BrowserFindInContent: Reached maximum match time of ${this._maxMatchTime}ms.`)
+ this._exceed = true
+ break
+ }
+
+ if (this._matchCount >= this._maxMatchCount) {
+ console.warn(`BrowserFindInContent: Reached maximum match count of ${this._maxMatchCount}.`)
+ this._exceed = true
+ break
+ }
+
+ this._matchCount++
+ if (regex) {
+ this._matches.push(match[0])
+ }
+ }
+ }
+
+ getStats () {
+ return {
+ count: this._matchCount,
+ current: this._currentMatchIndex,
+ exceed: this._exceed,
+ }
+ }
+
+ next (): boolean {
+ return this._search(false)
+ }
+
+ prev (): boolean {
+ return this._search(true)
+ }
+
+ private _search (backward: boolean): boolean {
+ this._win.document.body.focus()
+ let pattern = this._pattern
+
+ let index = this._currentMatchIndex + (backward ? -1 : 1)
+ if (index < 0) {
+ index = 0
+ }
+
+ if (this._opts.regex) {
+ pattern = this._matches[index % this._matches.length]
+ }
+
+ console.log('BrowserFindInContent: Searching for pattern', pattern, 'index', index)
+
+ if (!pattern) {
+ return true
+ }
+
+ const found = (this._win as any).find(
+ pattern,
+ !!(this._opts.caseSensitive),
+ backward,
+ !!this._wrapAround
+ )
+
+ if (found || this._opts.regex) {
+ this._currentMatchIndex = index
+ }
+
+ return found
+ }
+}
diff --git a/src/renderer/others/fuzzy-match.ts b/src/renderer/others/fuzzy-match.ts
new file mode 100644
index 000000000..2d16a1f48
--- /dev/null
+++ b/src/renderer/others/fuzzy-match.ts
@@ -0,0 +1,195 @@
+// https://github.com/forrestthewoods/lib_fts/blob/master/code/fts_fuzzy_match.js
+
+// LICENSE
+//
+// This software is dual-licensed to the public domain and under the following
+// license: you are granted a perpetual, irrevocable license to copy, modify,
+// publish, and distribute this file as you see fit.
+//
+// VERSION
+// 0.1.0 (2016-03-28) Initial release
+//
+// AUTHOR
+// Forrest Smith
+//
+// CONTRIBUTORS
+// J�rgen Tjern� - async helper
+// Anurag Awasthi - updated to 0.2.0
+
+const SEQUENTIAL_BONUS = 15 // bonus for adjacent matches
+const SEPARATOR_BONUS = 30 // bonus if match occurs after a separator
+const CAMEL_BONUS = 30 // bonus if match is uppercase and prev is lower
+const FIRST_LETTER_BONUS = 15 // bonus if the first letter is matched
+
+const LEADING_LETTER_PENALTY = -5 // penalty applied for every letter in str before the first match
+const MAX_LEADING_LETTER_PENALTY = -15 // maximum penalty for leading letters
+const UNMATCHED_LETTER_PENALTY = -1
+
+/**
+ * Does a fuzzy search to find pattern inside a string.
+ * @param {*} pattern string pattern to search for
+ * @param {*} str string string which is being searched
+ * @returns [boolean, number] a boolean which tells if pattern was
+ * found or not and a search score
+ */
+export function fuzzyMatch (pattern: string, str: string) {
+ const recursionCount = 0
+ const recursionLimit = 10
+ const matches: never[] = []
+ const maxMatches = 256
+
+ const [matched, score] = fuzzyMatchRecursive(
+ pattern,
+ str,
+ 0 /* patternCurIndex */,
+ 0 /* strCurrIndex */,
+ null /* srcMatces */,
+ matches,
+ maxMatches,
+ 0 /* nextMatch */,
+ recursionCount,
+ recursionLimit
+ )
+
+ return { matched, score }
+}
+
+function fuzzyMatchRecursive (
+ pattern: string | any[],
+ str: string | any[],
+ patternCurIndex: number,
+ strCurrIndex: number,
+ srcMatces: null,
+ matches: any,
+ maxMatches: number,
+ nextMatch: number,
+ recursionCount: number,
+ recursionLimit: number
+): [boolean, number] {
+ let outScore = 0
+
+ // Return if recursion limit is reached.
+ if (++recursionCount >= recursionLimit) {
+ return [false, outScore]
+ }
+
+ // Return if we reached ends of strings.
+ if (patternCurIndex === pattern.length || strCurrIndex === str.length) {
+ return [false, outScore]
+ }
+
+ // Recursion params
+ let recursiveMatch = false
+ let bestRecursiveMatches: any[] = []
+ let bestRecursiveScore = 0
+
+ // Loop through pattern and str looking for a match.
+ let firstMatch = true
+ while (patternCurIndex < pattern.length && strCurrIndex < str.length) {
+ // Match found.
+ if (
+ pattern[patternCurIndex].toLowerCase() === str[strCurrIndex].toLowerCase()
+ ) {
+ if (nextMatch >= maxMatches) {
+ return [false, outScore]
+ }
+
+ if (firstMatch && srcMatces) {
+ matches = [...srcMatces]
+ firstMatch = false
+ }
+
+ const recursiveMatches: never[] = []
+ const [matched, recursiveScore] = fuzzyMatchRecursive(
+ pattern,
+ str,
+ patternCurIndex,
+ strCurrIndex + 1,
+ matches,
+ recursiveMatches,
+ maxMatches,
+ nextMatch,
+ recursionCount,
+ recursionLimit
+ )
+
+ if (matched) {
+ // Pick best recursive score.
+ if (!recursiveMatch || recursiveScore > bestRecursiveScore) {
+ bestRecursiveMatches = [...recursiveMatches]
+ bestRecursiveScore = recursiveScore
+ }
+ recursiveMatch = true
+ }
+
+ matches[nextMatch++] = strCurrIndex
+ ++patternCurIndex
+ }
+ ++strCurrIndex
+ }
+
+ const matched = patternCurIndex === pattern.length
+
+ if (matched) {
+ outScore = 100
+
+ // Apply leading letter penalty
+ let penalty = LEADING_LETTER_PENALTY * matches[0]
+ penalty =
+ penalty < MAX_LEADING_LETTER_PENALTY
+ ? MAX_LEADING_LETTER_PENALTY
+ : penalty
+ outScore += penalty
+
+ // Apply unmatched penalty
+ const unmatched = str.length - nextMatch
+ outScore += UNMATCHED_LETTER_PENALTY * unmatched
+
+ // Apply ordering bonuses
+ for (let i = 0; i < nextMatch; i++) {
+ const currIdx = matches[i]
+
+ if (i > 0) {
+ const prevIdx = matches[i - 1]
+ if (currIdx === prevIdx + 1) {
+ outScore += SEQUENTIAL_BONUS
+ }
+ }
+
+ // Check for bonuses based on neighbor character value.
+ if (currIdx > 0) {
+ // Camel case
+ const neighbor = str[currIdx - 1]
+ const curr = str[currIdx]
+ if (
+ neighbor !== neighbor.toUpperCase() &&
+ curr !== curr.toLowerCase()
+ ) {
+ outScore += CAMEL_BONUS
+ }
+ const isNeighbourSeparator = neighbor === '_' || neighbor === ' '
+ if (isNeighbourSeparator) {
+ outScore += SEPARATOR_BONUS
+ }
+ } else {
+ // First letter
+ outScore += FIRST_LETTER_BONUS
+ }
+ }
+
+ // Return best result
+ if (recursiveMatch && (!matched || bestRecursiveScore > outScore)) {
+ // Recursive score is better than "this"
+ matches = [...bestRecursiveMatches]
+ outScore = bestRecursiveScore
+ return [true, outScore]
+ } else if (matched) {
+ // "this" score is better than recursive
+ return [true, outScore]
+ } else {
+ return [false, outScore]
+ }
+ }
+
+ return [false, outScore]
+}
diff --git a/src/renderer/others/google-analytics.ts b/src/renderer/others/google-analytics.ts
new file mode 100644
index 000000000..208d2118d
--- /dev/null
+++ b/src/renderer/others/google-analytics.ts
@@ -0,0 +1,412 @@
+// https://gist.github.com/IjzerenHein/df3f65093038dd70ad871f926be6f45e/6b50659729b0acd8c80eabb30bc01df0d5a47d0a
+
+export type FirebaseAnalyticsJSCodedEvent = { [key: string]: any };
+
+export interface FirebaseAnalyticsJSConfig {
+ /**
+ * **(Required)** Measurement-Id as found in the web Firebase-config.
+ * The format is G-XXXXXXXXXX.
+ */
+ measurementId: string;
+}
+
+export interface FirebaseAnalyticsJSOptions {
+ /**
+ * **(Required)** Anonymously identifies a particular user, device, or browser instance.
+ * For the web, this is generally stored as a first-party cookie with a two-year expiration.
+ * For mobile apps, this is randomly generated for each particular instance of an application install.
+ * The value of this field should be a random UUID (version 4) as described in http://www.ietf.org/rfc/rfc4122.txt.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#cid
+ */
+ clientId: string;
+
+ /**
+ * Max cache time in msec (default = 5000).
+ * Caches events fired within a certain time-frame and then
+ * sends them to the Google Measurement API in a single batch.
+ */
+ maxCacheTime?: number;
+
+ /**
+ * Enables strict data format checks for logEvent and setUserProperties.
+ * When enabled, causes `logEvent` and `setUserProperties` to strictly check
+ * whether any event- names & values and user-properties conform to the
+ * native SDK requirements.
+ */
+ strictNativeEmulation?: boolean;
+
+ /**
+ * Document title (e.g. "My Awesome Page").
+ * This is a browser specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#dt
+ */
+ docTitle?: string;
+
+ /**
+ * Document location URL (e.g. "https://myawesomeapp.com").
+ * This is a browser specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#dl
+ */
+ docLocation?: string;
+
+ /**
+ * Screen-resolution in the format "WxH" (e.g "2000x1440").
+ * This is a browser specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#sr
+ */
+ screenRes?: string;
+
+ /**
+ * Application name (e.g. "My Awesome App").
+ * This is a mobile app specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#an
+ */
+ appName?: string;
+
+ /**
+ * Application version (e.g. "1.2").
+ * This is a mobile app specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#av
+ */
+ appVersion?: string;
+
+ /**
+ * User language (e.g. "en-us").
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#ul
+ */
+ userLanguage?: string;
+
+ /**
+ * Origin (default = "firebase").
+ */
+ origin?: string;
+
+ /**
+ * Custom query arguments that are appended to the POST request that is send to the
+ * Google Measurement API v2.
+ *
+ * @example
+ * ```
+ * const analytics = new FirebaseAnalyticsJS(config, {
+ * appName: 'My Awesome App',
+ * customArg: {
+ * vp: '123x456', // Add viewport-size
+ * sd: '24-bits' // Add screen-colors
+ * }
+ * });
+ * ```
+ */
+ customArgs?: { [key: string]: any };
+}
+
+/**
+ * A pure JavaScript Google Firebase Analytics implementation that uses
+ * the HTTPS Measurement API 2 to send events to Google Analytics.
+ *
+ * This class provides an alternative for the Firebase Analytics module
+ * shipped with the Firebase JS SDK. That library uses the gtag.js dependency
+ * and requires certain browser features. This prevents the use
+ * analytics on other platforms, such as Node-js and react-native.
+ *
+ * FirebaseAnalyticsJS provides a bare-bone implementation of the new
+ * HTTPS Measurement API 2 protocol (which is undocumented), with an API
+ * that follows the Firebase Analytics JS SDK.
+ */
+export class FirebaseAnalyticsJS {
+ public readonly url: string
+ private enabled: boolean
+ public readonly config: FirebaseAnalyticsJSConfig
+ private userId?: string
+ private userProperties?: { [key: string]: any }
+ private screenName?: string
+ private eventQueue = new Set()
+ private options: FirebaseAnalyticsJSOptions
+ private flushEventsPromise: Promise = Promise.resolve()
+ private flushEventsTimer: any
+
+ constructor (config: FirebaseAnalyticsJSConfig, options: FirebaseAnalyticsJSOptions) {
+ // Verify the measurement- & client Ids
+ if (!config.measurementId) {
+ throw new Error(
+ 'No valid measurementId. Make sure to provide a valid measurementId with a G-XXXXXXXXXX format.'
+ )
+ }
+ if (!options.clientId) {
+ throw new Error(
+ 'No valid clientId. Make sure to provide a valid clientId with a UUID (v4) format.'
+ )
+ }
+
+ // Initialize
+ this.url = 'https://www.google-analytics.com/g/collect'
+ this.enabled = true
+ this.config = config
+ this.options = {
+ customArgs: {},
+ maxCacheTime: 5000,
+ strictNativeEmulation: false,
+ origin: 'firebase',
+ ...options,
+ }
+ }
+
+ /**
+ * Sends 1 or more coded-events to the back-end.
+ * When only 1 event is provided, it is send inside the query URL.
+ * When more than 1 event is provided, the event-data is send in
+ * the body of the POST request.
+ */
+ private async send (events: Set): Promise {
+ const { config, options } = this
+ let queryArgs: any = {
+ ...options.customArgs,
+ v: 2,
+ tid: config.measurementId,
+ cid: this.options.clientId,
+ }
+ if (options.userLanguage) queryArgs.ul = options.userLanguage
+ if (options.appName) queryArgs.an = options.appName
+ if (options.appVersion) queryArgs.av = options.appVersion
+ if (options.docTitle) queryArgs.dt = options.docTitle
+ if (options.docLocation) queryArgs.dl = options.docLocation
+ if (options.screenRes) queryArgs.sr = options.screenRes
+ let body = ''
+
+ if (events.size > 1) {
+ body = ''
+ events.forEach(event => {
+ body += encodeQueryArgs(event) + '\n'
+ })
+ } else if (events.size === 1) {
+ const event = events.values().next().value
+ queryArgs = {
+ ...event,
+ ...queryArgs,
+ }
+ }
+ const args = encodeQueryArgs(queryArgs)
+ await fetch(`${this.url}?${args}`, {
+ method: 'POST',
+ cache: 'no-cache',
+ body,
+ })
+ }
+
+ private async addEvent (event: FirebaseAnalyticsJSCodedEvent) {
+ const { userId, userProperties, screenName } = this
+
+ // Extend the event with the currently set User-id
+ if (userId) event.uid = userId
+ if (screenName) event['ep.screen_name'] = screenName
+
+ // Add user-properties
+ if (userProperties) {
+ for (const name in userProperties) {
+ event[name] = userProperties[name]
+ }
+
+ // Reset user-properties after the first event. This is what gtag.js seems
+ // to do as well, although I couldn't find any docs explaining this behavior.
+ this.userProperties = undefined
+ }
+
+ // Add the event to the queue
+ this.eventQueue.add(event)
+
+ // Start debounce timer
+ if (!this.flushEventsTimer) {
+ this.flushEventsTimer = setTimeout(async () => {
+ this.flushEventsTimer = undefined
+ try {
+ await this.flushEventsPromise
+ } catch (err) {
+ // nop
+ }
+ this.flushEventsPromise = this.flushEvents()
+ }, this.options.maxCacheTime)
+ }
+ }
+
+ private async flushEvents () {
+ if (!this.eventQueue.size) return
+ const events = new Set(this.eventQueue)
+ await this.send(events)
+ events.forEach(event => this.eventQueue.delete(event))
+ }
+
+ /**
+ * Clears any queued events and cancels the flush timer.
+ */
+ clearEvents () {
+ this.eventQueue.clear()
+ if (this.flushEventsTimer) {
+ clearTimeout(this.flushEventsTimer)
+ this.flushEventsTimer = 0
+ }
+ }
+
+ /**
+ * Parses an event (as passed to logEvent) and throws an error when the
+ * event-name or parameters are invalid.
+ *
+ * Upon success, returns the event in encoded format, ready to be send
+ * through the Google Measurement API v2.
+ */
+ static parseEvent (
+ options: FirebaseAnalyticsJSOptions,
+ eventName: string,
+ eventParams?: { [key: string]: any }
+ ): FirebaseAnalyticsJSCodedEvent {
+ if (
+ !eventName ||
+ !eventName.length ||
+ eventName.length > 40 ||
+ eventName[0] === '_' ||
+ !eventName.match(/^[A-Za-z_]+$/) ||
+ eventName.startsWith('firebase_') ||
+ eventName.startsWith('google_') ||
+ eventName.startsWith('ga_')
+ ) {
+ throw new Error(
+ 'Invalid event-name specified. Should contain 1 to 40 alphanumeric characters or underscores. The name must start with an alphabetic character.'
+ )
+ }
+ const params: FirebaseAnalyticsJSCodedEvent = {
+ en: eventName,
+ _et: Date.now(),
+ 'ep.origin': options.origin,
+ }
+ if (eventParams) {
+ for (const key in eventParams) {
+ const paramKey =
+ (SHORT_EVENT_PARAMS as any)[key] ||
+ (typeof eventParams[key] === 'number' ? `epn.${key}` : `ep.${key}`)
+ params[paramKey] = eventParams[key]
+ }
+ }
+ return params
+ }
+
+ /**
+ * Parses user-properties (as passed to setUserProperties) and throws an error when
+ * one of the user properties is invalid.
+ *
+ * Upon success, returns the user-properties in encoded format, ready to be send
+ * through the Google Measurement API v2.
+ */
+ static parseUserProperty (
+ options: FirebaseAnalyticsJSOptions,
+ userPropertyName: string,
+ userPropertyValue: any
+ ): string {
+ if (
+ !userPropertyName.length ||
+ userPropertyName.length > 24 ||
+ userPropertyName[0] === '_' ||
+ !userPropertyName.match(/^[A-Za-z_]+$/) ||
+ userPropertyName === 'user_id' ||
+ userPropertyName.startsWith('firebase_') ||
+ userPropertyName.startsWith('google_') ||
+ userPropertyName.startsWith('ga_')
+ ) {
+ throw new Error(
+ 'Invalid user-property name specified. Should contain 1 to 24 alphanumeric characters or underscores. The name must start with an alphabetic character.'
+ )
+ }
+ if (
+ userPropertyValue !== undefined &&
+ userPropertyValue !== null &&
+ options.strictNativeEmulation &&
+ (typeof userPropertyValue !== 'string' || userPropertyValue.length > 36)
+ ) {
+ throw new Error(
+ 'Invalid user-property value specified. Value should be a string of up to 36 characters long.'
+ )
+ }
+ return typeof userPropertyValue === 'number'
+ ? `upn.${userPropertyName}`
+ : `up.${userPropertyName}`
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#log-event
+ */
+ async logEvent (eventName: string, eventParams?: { [key: string]: any }): Promise {
+ const event = FirebaseAnalyticsJS.parseEvent(this.options, eventName, eventParams)
+ if (!this.enabled) return
+ return this.addEvent(event)
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-analytics-collection-enabled
+ */
+ async setAnalyticsCollectionEnabled (isEnabled: boolean): Promise {
+ this.enabled = isEnabled
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-current-screen
+ */
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ async setCurrentScreen (screenName?: string, screenClassOverride?: string): Promise {
+ if (screenName && screenName.length > 100) {
+ throw new Error(
+ 'Invalid screen-name specified. Should contain 1 to 100 characters. Set to undefined to clear the current screen name.'
+ )
+ }
+ if (!this.enabled) return
+ this.screenName = screenName || undefined
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-user-id
+ */
+ async setUserId (userId: string | null): Promise {
+ if (!this.enabled) return
+ this.userId = userId || undefined
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-user-properties
+ */
+ async setUserProperties (userProperties: { [key: string]: any }): Promise {
+ if (!this.enabled) return
+ for (const name in userProperties) {
+ const val = userProperties[name]
+ const key = FirebaseAnalyticsJS.parseUserProperty(this.options, name, val)
+ if (val === null || val === undefined) {
+ if (this.userProperties) {
+ delete this.userProperties[key]
+ }
+ } else {
+ this.userProperties = this.userProperties || {}
+ this.userProperties[key] = val
+ }
+ }
+ }
+
+ /**
+ * Clears all analytics data for this instance.
+ */
+ async resetAnalyticsData () {
+ this.clearEvents()
+ this.screenName = undefined
+ this.userId = undefined
+ this.userProperties = undefined
+ }
+}
+
+function encodeQueryArgs (queryArgs: FirebaseAnalyticsJSCodedEvent): string {
+ const now = Date.now()
+ return Object.keys(queryArgs)
+ .map(key => {
+ return `${key}=${encodeURIComponent(
+ key === '_et' ? Math.max(now - queryArgs[key], 0) : queryArgs[key]
+ )}`
+ })
+ .join('&')
+}
+
+const SHORT_EVENT_PARAMS = {
+ currency: 'cu',
+}
diff --git a/src/renderer/others/indexer-worker.ts b/src/renderer/others/indexer-worker.ts
new file mode 100644
index 000000000..16433a638
--- /dev/null
+++ b/src/renderer/others/indexer-worker.ts
@@ -0,0 +1,343 @@
+import AsyncLock from 'async-lock'
+import MarkdownIt, { Token } from 'markdown-it'
+import { debounce, throttle } from 'lodash-es'
+import { JSONRPCClient, JSONRPCClientChannel, JSONRPCRequest, JSONRPCResponse, JSONRPCServer, JSONRPCServerChannel } from 'jsonrpc-bridge'
+import { fetchTree, readFile, watchFs } from '@fe/support/api'
+import { DOM_ATTR_NAME, FLAG_DEBUG, FLAG_DEMO, HELP_REPO_NAME, MODE } from '@fe/support/args'
+import * as utils from '@fe/utils/pure'
+import { DocumentEntity, documents } from '@fe/others/db'
+import type { Stats } from 'fs'
+import type { PathItem, Repo } from '@share/types'
+import type { IndexerHostExports } from '@fe/services/indexer'
+import type { Components, IndexItemLink, IndexItemResource } from '@fe/types'
+import { registerHook, removeHook, triggerHook } from '@fe/core/hook'
+import { isAnchorToken, isDataUrl, isResourceToken, parseLink } from '@fe/plugins/markdown-link/lib'
+
+const markdown = MarkdownIt({ linkify: false, breaks: true, html: true })
+
+markdown.core.ruler.at('inline', function (state) {
+ const tokens = state.tokens
+
+ for (let i = 0, l = tokens.length; i < l; i++) {
+ const tok = tokens[i]
+ if (tok.type === 'inline') {
+ state.md.inline.parse(tok.content, state.md, state.env, tok.children as any)
+
+ let map = tok.map
+
+ if (!map) {
+ // find previous token with map info
+ for (let j = i - 1; j >= 0; j--) {
+ if (tokens[j].map) {
+ map = tokens[j].map
+ break
+ }
+ }
+ }
+
+ for (let j = 0; j < tok.children!.length; j++) {
+ const token = tok.children![j]
+ ;(token as any)._block_map = map
+ }
+ }
+ }
+})
+
+const exportMain = {
+ triggerWatchRepo,
+ stopWatch,
+ importScripts: async (urlOrCode: string, isCode = false) => {
+ if (isCode) {
+ const url = URL.createObjectURL(new Blob([urlOrCode], { type: 'application/javascript' }))
+ await import(/* @vite-ignore */ url)
+ URL.revokeObjectURL(url)
+ } else {
+ await import(/* @vite-ignore */ urlOrCode)
+ }
+ },
+}
+
+class WorkerChannel implements JSONRPCServerChannel, JSONRPCClientChannel {
+ type: 'server' | 'client'
+
+ constructor (type: 'server' | 'client') {
+ this.type = type
+ }
+
+ send (message: JSONRPCRequest & JSONRPCResponse): void {
+ if (this.type === 'client' && 'method' in message) {
+ self.postMessage({ from: 'worker', message })
+ } else if (this.type === 'server' && 'result' in message) {
+ self.postMessage({ from: 'worker', message })
+ }
+ }
+
+ setMessageHandler (callback: (message: JSONRPCResponse & JSONRPCRequest) => void): void {
+ self.addEventListener('message', (event) => {
+ const { message, from } = event.data
+ if (from !== 'host') {
+ return
+ }
+
+ if (this.type === 'client' && 'result' in message) {
+ callback(message)
+ } else if (this.type === 'server' && 'method' in message) {
+ callback(message)
+ }
+ })
+ }
+}
+
+export type IndexerWorkerExports = { main: typeof exportMain }
+
+export interface IndexerWorkerCtx {
+ markdown: MarkdownIt;
+ bridgeClient: JSONRPCClient;
+ registerHook: typeof registerHook;
+ removeHook: typeof removeHook;
+ utils: typeof utils;
+}
+
+// provide main to host
+const bridgeServer = new JSONRPCServer(new WorkerChannel('server'), { debug: FLAG_DEBUG })
+bridgeServer.addModule('main', exportMain)
+
+// to call host
+const bridgeClient = new JSONRPCClient(new WorkerChannel('client'), { debug: FLAG_DEBUG })
+
+const processingStatus = {
+ total: 0,
+ indexed: 0,
+ ready: false,
+ startTime: 0,
+}
+
+function _reportStatus (repo: Repo, processing: string | null, cost: number) {
+ const { total, indexed, ready } = processingStatus
+ bridgeClient.call.ctx.indexer.updateIndexStatus(repo, { ready, total, indexed, processing, cost })
+}
+
+function _convertPathToPathItem (repo: Repo, payload: { path: string }): PathItem {
+ const relativePath = '/' + utils.path.relative(repo.path, payload.path)
+ return { repo: repo.name, path: relativePath }
+}
+
+const reportStatus = throttle(_reportStatus, 500, { leading: true, trailing: true })
+
+let repoFiles: Components.Tree.Node[] = [] // TODO cache
+let allMtimeMs: Map | null = null
+let toPutItems: (Omit & { id?: number })[] = []
+let reusedIds: number[] = []
+
+const triggerFsChangeHook = debounce((repo: Repo) => {
+ if (processingStatus.ready) {
+ bridgeClient.notify.ctx.triggerHook('INDEXER_FS_CHANGE', { repo })
+ }
+}, 500)
+
+class RepoWatcher {
+ logger = utils.getLogger('indexer-worker-repo-watcher')
+
+ lock = new AsyncLock()
+
+ // type Awaited = T extends PromiseLike ? Awaited : T;
+ handler: Awaited> | null = null
+
+ stopWatch () {
+ this.logger.debug('stopWatch', !!this.handler)
+ if (this.handler) {
+ this.handler.abort()
+ this.handler = null
+ }
+ }
+
+ private async _startWatch (repo: Repo) {
+ if (!repo.enableIndexing || repo.name === HELP_REPO_NAME || FLAG_DEMO || MODE !== 'normal') {
+ this.logger.debug('startWatch', 'skip', repo)
+ this.stopWatch()
+ return
+ }
+
+ this.logger.debug('startWatch', repo)
+
+ const ignored = ((await bridgeClient.call.ctx.setting.getSetting('tree.exclude')) || '') as string
+
+ processingStatus.total = 0
+ processingStatus.indexed = 0
+ processingStatus.ready = false
+ processingStatus.startTime = Date.now()
+
+ const include = '/$|.md$' // dir or md file
+
+ const initRes = await Promise.all([
+ fetchTree(repo.name, { by: 'mtime', order: 'desc' }, include, true).catch(() => []),
+ documents.findAllMtimeMsByRepo(repo.name),
+ ])
+
+ repoFiles = initRes[0]
+ allMtimeMs = initRes[1]
+ toPutItems = []
+ reusedIds = []
+
+ await triggerHook('WORKER_INDEXER_BEFORE_START_WATCH', { repo }, { breakable: true })
+
+ this.handler = await watchFs(
+ repo.name,
+ '/**/*',
+ { awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 50 }, alwaysStat: true, ignored, mdContent: true, mdFilesOnly: true },
+ async payload => {
+ this.logger.debug('startWatch onResult', payload.eventName, (payload as any).path)
+
+ if (processingStatus.ready && payload.eventName !== 'change' && payload.eventName !== 'ready') {
+ triggerFsChangeHook(repo)
+ }
+
+ if (payload.eventName === 'add' || payload.eventName === 'change') {
+ try {
+ if (!processingStatus.ready) {
+ processingStatus.total++
+ reportStatus(repo, payload.path, Date.now() - processingStatus.startTime)
+ }
+
+ await processMarkdownFile(repo, payload)
+ processingStatus.indexed++
+ } catch (error) {
+ this.logger.error('processFile error', error)
+ }
+ } else if (payload.eventName === 'ready') {
+ allMtimeMs = null
+ processingStatus.ready = true
+ const ids = toPutItems.length ? await documents.bulkPut(toPutItems) : []
+ await documents.deleteUnusedInRepo(repo.name, reusedIds.concat(ids))
+ toPutItems = []
+ reusedIds = []
+
+ reportStatus(repo, null, Date.now() - processingStatus.startTime)
+ } else if (payload.eventName === 'unlink') {
+ const doc = _convertPathToPathItem(repo, payload)
+ await documents.deletedByRepoAndPath(doc.repo, doc.path)
+ }
+ },
+ async error => {
+ this.logger.error('startWatch error', error)
+
+ // ignore system error
+ if ((error as any)?.syscall) {
+ return
+ }
+
+ // retry watch then other error occurred
+ await utils.sleep(2000)
+ this.triggerWatchRepo(repo)
+ }
+ )
+ }
+
+ async triggerWatchRepo (repo: Repo | null | undefined) {
+ this.lock.acquire('triggerWatch', async (done) => {
+ this.logger.debug('triggerWatch', repo)
+ this.stopWatch()
+ try {
+ if (repo?.name && repo?.path) {
+ await this._startWatch(repo)
+ }
+ } finally {
+ done()
+ }
+ })
+ }
+}
+
+const logger = utils.getLogger('indexer-worker')
+const watcher = new RepoWatcher()
+
+function triggerWatchRepo (repo: Repo | null | undefined) {
+ watcher.triggerWatchRepo(repo)
+}
+
+function stopWatch () {
+ watcher.stopWatch()
+}
+
+async function processMarkdownFile (repo: Repo, payload: { content?: string | null, path: string, stats?: Stats }): Promise {
+ const doc = _convertPathToPathItem(repo, payload)
+
+ const oldRecord = allMtimeMs ? allMtimeMs.get(doc.path) : await documents.findByRepoAndPath(doc.repo, doc.path)
+
+ if (oldRecord && oldRecord.mtimeMs === payload.stats?.mtimeMs) {
+ logger.debug('skip', oldRecord.id, doc.path)
+ reusedIds.push(oldRecord.id)
+ return
+ }
+
+ let content: string
+ if (typeof payload.content === 'string') {
+ content = payload.content
+ } else {
+ const res = await readFile(doc)
+ content = res.content
+ }
+
+ const env: Record = { file: doc }
+ const tokens = markdown.parse(content, env)
+
+ const links: IndexItemLink[] = []
+ const resources: IndexItemResource[] = []
+
+ const convert = (tokens: Token[]) => {
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i]
+ if (isAnchorToken(token)) {
+ const href = token.attrGet('href') || ''
+ const blockMap = (token as any)._block_map
+ if (!isDataUrl(href)) {
+ const isWikiLink = !!token.attrGet(DOM_ATTR_NAME.WIKI_LINK)
+ const parsedLink = isWikiLink ? parseLink(doc, href, true, repoFiles) : parseLink(doc, href, false)
+ if (parsedLink?.type === 'external') {
+ links.push({ href, internal: null, position: null, blockMap })
+ } else if (parsedLink?.type === 'internal') {
+ links.push({ href, internal: parsedLink.path, position: parsedLink.position, blockMap })
+ }
+ }
+ } else if (isResourceToken(token)) {
+ const path = token.attrGet(DOM_ATTR_NAME.TARGET_PATH)
+ const src = token.attrGet('src') || ''
+
+ if (!isDataUrl(src)) {
+ const blockMap = (token as any)._block_map
+ resources.push({ src, internal: path, tag: token.tag as any, blockMap })
+ }
+ }
+
+ if (token.children) {
+ convert(token.children)
+ }
+ }
+ }
+
+ convert(tokens)
+
+ const item = {
+ id: oldRecord?.id,
+ repo: doc.repo,
+ path: doc.path,
+ name: utils.path.basename(doc.path),
+ links,
+ resources,
+ frontmatter: env.attributes || {},
+ ctimeMs: payload.stats?.ctimeMs || 0,
+ mtimeMs: payload.stats?.mtimeMs || 0,
+ size: payload.stats?.size || 0,
+ }
+
+ if (processingStatus.ready) {
+ documents.put(item)
+ } else {
+ toPutItems.push(item)
+ }
+}
+
+// expose to plugin
+self.ctx = { bridgeClient, markdown, registerHook, removeHook, utils } satisfies IndexerWorkerCtx
+
+logger.debug('indexer-worker loaded', self.location.href)
diff --git a/src/renderer/others/monaco-indent-range-provider.js b/src/renderer/others/monaco-indent-range-provider.js
new file mode 100644
index 000000000..c7d62c9ac
--- /dev/null
+++ b/src/renderer/others/monaco-indent-range-provider.js
@@ -0,0 +1,181 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { FoldingRegions, MAX_LINE_NUMBER } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/foldingRanges.js';
+const MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT = 5000;
+export const ID_INDENT_PROVIDER = 'indent';
+export class IndentRangeProvider {
+ constructor(editorModel) {
+ this.editorModel = editorModel;
+ this.id = ID_INDENT_PROVIDER;
+ }
+ dispose() {
+ }
+ compute(cancelationToken) {
+ return Promise.resolve(computeRanges(this.editorModel, false, undefined));
+ }
+}
+
+const TextModel = {
+ computeIndentLevel(line, tabSize) {
+ let indent = 0;
+ let i = 0;
+ let len = line.length;
+ while (i < len) {
+ let chCode = line.charCodeAt(i);
+ if (chCode === 32 /* Space */) {
+ indent++;
+ }
+ else if (chCode === 9 /* Tab */) {
+ indent = indent - indent % tabSize + tabSize;
+ }
+ else {
+ break;
+ }
+ i++;
+ }
+ if (i === len) {
+ return -1; // line only consists of whitespace
+ }
+ return indent;
+ }
+}
+
+// public only for testing
+export class RangesCollector {
+ constructor(foldingRangesLimit) {
+ this._startIndexes = [];
+ this._endIndexes = [];
+ this._indentOccurrences = [];
+ this._length = 0;
+ this._foldingRangesLimit = foldingRangesLimit;
+ }
+ insertFirst(startLineNumber, endLineNumber, indent) {
+ if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {
+ return;
+ }
+ let index = this._length;
+ this._startIndexes[index] = startLineNumber;
+ this._endIndexes[index] = endLineNumber;
+ this._length++;
+ if (indent < 1000) {
+ this._indentOccurrences[indent] = (this._indentOccurrences[indent] || 0) + 1;
+ }
+ }
+ toIndentRanges(model) {
+ if (this._length <= this._foldingRangesLimit) {
+ // reverse and create arrays of the exact length
+ let startIndexes = new Uint32Array(this._length);
+ let endIndexes = new Uint32Array(this._length);
+ for (let i = this._length - 1, k = 0; i >= 0; i--, k++) {
+ startIndexes[k] = this._startIndexes[i];
+ endIndexes[k] = this._endIndexes[i];
+ }
+ return new FoldingRegions(startIndexes, endIndexes);
+ }
+ else {
+ let entries = 0;
+ let maxIndent = this._indentOccurrences.length;
+ for (let i = 0; i < this._indentOccurrences.length; i++) {
+ let n = this._indentOccurrences[i];
+ if (n) {
+ if (n + entries > this._foldingRangesLimit) {
+ maxIndent = i;
+ break;
+ }
+ entries += n;
+ }
+ }
+ const tabSize = model.getOptions().tabSize;
+ // reverse and create arrays of the exact length
+ let startIndexes = new Uint32Array(this._foldingRangesLimit);
+ let endIndexes = new Uint32Array(this._foldingRangesLimit);
+ for (let i = this._length - 1, k = 0; i >= 0; i--) {
+ let startIndex = this._startIndexes[i];
+ let lineContent = model.getLineContent(startIndex);
+ let indent = TextModel.computeIndentLevel(lineContent, tabSize);
+ if (indent < maxIndent || (indent === maxIndent && entries++ < this._foldingRangesLimit)) {
+ startIndexes[k] = startIndex;
+ endIndexes[k] = this._endIndexes[i];
+ k++;
+ }
+ }
+ return new FoldingRegions(startIndexes, endIndexes);
+ }
+ }
+}
+export function computeRanges(model, offSide, markers, foldingRangesLimit = MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT) {
+ const tabSize = model.getOptions().tabSize;
+ let result = new RangesCollector(foldingRangesLimit);
+ let pattern = undefined;
+ if (markers) {
+ pattern = new RegExp(`(${markers.start.source})|(?:${markers.end.source})`);
+ }
+ let previousRegions = [];
+ let line = model.getLineCount() + 1;
+ previousRegions.push({ indent: -1, endAbove: line, line }); // sentinel, to make sure there's at least one entry
+ for (let line = model.getLineCount(); line > 0; line--) {
+ let lineContent = model.getLineContent(line);
+ let indent = TextModel.computeIndentLevel(lineContent, tabSize);
+ let previous = previousRegions[previousRegions.length - 1];
+ if (indent === -1) {
+ if (offSide) {
+ // for offSide languages, empty lines are associated to the previous block
+ // note: the next block is already written to the results, so this only
+ // impacts the end position of the block before
+ previous.endAbove = line;
+ }
+ continue; // only whitespace
+ }
+ let m;
+ if (pattern && (m = lineContent.match(pattern))) {
+ // folding pattern match
+ if (m[1]) { // start pattern match
+ // discard all regions until the folding pattern
+ let i = previousRegions.length - 1;
+ while (i > 0 && previousRegions[i].indent !== -2) {
+ i--;
+ }
+ if (i > 0) {
+ previousRegions.length = i + 1;
+ previous = previousRegions[i];
+ // new folding range from pattern, includes the end line
+ result.insertFirst(line, previous.line, indent);
+ previous.line = line;
+ previous.indent = indent;
+ previous.endAbove = line;
+ continue;
+ }
+ else {
+ // no end marker found, treat line as a regular line
+ }
+ }
+ else { // end pattern match
+ previousRegions.push({ indent: -2, endAbove: line, line });
+ continue;
+ }
+ }
+ if (previous.indent > indent) {
+ // discard all regions with larger indent
+ do {
+ previousRegions.pop();
+ previous = previousRegions[previousRegions.length - 1];
+ } while (previous.indent > indent);
+ // new folding range
+ let endLineNumber = previous.endAbove - 1;
+ if (endLineNumber - line >= 1) { // needs at east size 1
+ result.insertFirst(line, endLineNumber, indent);
+ }
+ }
+ if (previous.indent === indent) {
+ previous.endAbove = line;
+ }
+ else { // previous.indent < indent
+ // new region with a bigger indent
+ previousRegions.push({ indent, endAbove: line, line });
+ }
+ }
+ return result.toIndentRanges(model);
+}
diff --git a/src/renderer/others/monaco-latex.ts b/src/renderer/others/monaco-latex.ts
new file mode 100644
index 000000000..509af299a
--- /dev/null
+++ b/src/renderer/others/monaco-latex.ts
@@ -0,0 +1,66 @@
+export default function (monacoEditor: any) {
+ monacoEditor.languages.register({ id: 'latex' })
+
+ monacoEditor.languages.setMonarchTokensProvider('latex', {
+ displayName: 'Latex',
+ name: 'latex',
+ mimeTypes: ['text/latex', 'text/tex'],
+ fileExtensions: ['tex', 'sty', 'cls'],
+
+ lineComment: '% ',
+
+ builtin: [
+ 'addcontentsline', 'addtocontents', 'addtocounter', 'address', 'addtolength', 'addvspace', 'alph', 'appendix',
+ 'arabic', 'author', 'backslash', 'baselineskip', 'baselinestretch', 'bf', 'bibitem', 'bigskipamount', 'bigskip',
+ 'boldmath', 'boldsymbol', 'cal', 'caption', 'cdots', 'centering', 'chapter', 'circle', 'cite', 'cleardoublepage',
+ 'clearpage', 'cline', 'closing', 'color', 'copyright', 'dashbox', 'date', 'ddots', 'documentclass', 'dotfill', 'em',
+ 'emph', 'ensuremath', 'epigraph', 'euro', 'fbox', 'flushbottom', 'fnsymbol', 'footnote', 'footnotemark',
+ 'footnotesize', 'footnotetext', 'frac', 'frame', 'framebox', 'frenchspacing', 'hfill', 'hline', 'href', 'hrulefill',
+ 'hspace', 'huge', 'Huge', 'hyphenation', 'include', 'includegraphics', 'includeonly', 'indent', 'input', 'it', 'item',
+ 'kill', 'label', 'large', 'Large', 'LARGE', 'LaTeX', 'LaTeXe', 'ldots', 'left', 'lefteqn', 'line', 'linebreak',
+ 'linethickness', 'linewidth', 'listoffigures', 'listoftables', 'location', 'makebox', 'maketitle', 'markboth',
+ 'mathcal', 'mathop', 'mbox', 'medskip', 'multicolumn', 'multiput', 'newcommand', 'newcolumntype', 'newcounter',
+ 'newenvironment', 'newfont', 'newlength', 'newline', 'newpage', 'newsavebox', 'newtheorem', 'nocite', 'noindent',
+ 'nolinebreak', 'nonfrenchspacing', 'normalsize', 'nopagebreak', 'not', 'onecolumn', 'opening', 'oval', 'overbrace',
+ 'overline', 'pagebreak', 'pagenumbering', 'pageref', 'pagestyle', 'par', 'paragraph', 'parbox', 'parindent', 'parskip',
+ 'part', 'protect', 'providecommand', 'put', 'raggedbottom', 'raggedleft', 'raggedright', 'raisebox', 'ref',
+ 'renewcommand', 'right', 'rm', 'roman', 'rule', 'savebox', 'sbox', 'sc', 'scriptsize', 'section', 'setcounter',
+ 'setlength', 'settowidth', 'sf', 'shortstack', 'signature', 'sl', 'slash', 'small', 'smallskip', 'sout', 'space', 'sqrt',
+ 'stackrel', 'stepcounter', 'subparagraph', 'subsection', 'subsubsection', 'tableofcontents', 'telephone', 'TeX',
+ 'textbf', 'textcolor', 'textit', 'textmd', 'textnormal', 'textrm', 'textsc', 'textsf', 'textsl', 'texttt', 'textup',
+ 'textwidth', 'textheight', 'thanks', 'thispagestyle', 'tiny', 'title', 'today', 'tt', 'twocolumn', 'typeout', 'typein',
+ 'uline', 'underbrace', 'underline', 'unitlength', 'usebox', 'usecounter', 'uwave', 'value', 'vbox', 'vcenter', 'vdots',
+ 'vector', 'verb', 'vfill', 'vline', 'vphantom', 'vspace',
+
+ 'RequirePackage', 'NeedsTeXFormat', 'usepackage', 'input', 'include', 'documentclass', 'documentstyle',
+ 'def', 'edef', 'defcommand', 'if', 'ifdim', 'ifnum', 'ifx', 'fi', 'else', 'begingroup', 'endgroup',
+ 'definecolor', 'textcolor', 'color',
+ 'eifstrequal', 'eeifstrequal'
+ ],
+
+ tokenizer: {
+ root: [
+ ['(\\\\begin)(\\s*)(\\{)([\\w\\-\\*\\@]+)(\\})',
+ ['keyword.predefined', 'white', '@brackets', { token: 'tag.env-$4', bracket: '@open' }, '@brackets']],
+ ['(\\\\end)(\\s*)(\\{)([\\w\\-\\*\\@]+)(\\})',
+ ['keyword.predefined', 'white', '@brackets', { token: 'tag.env-$4', bracket: '@close' }, '@brackets']],
+ ['\\\\[^a-zA-Z@]', 'keyword'],
+ ['\\@[a-zA-Z@]+', 'keyword.at'],
+ ['\\\\([a-zA-Z@]+)', {
+ cases: {
+ '$1@builtin': 'keyword.predefined',
+ '@default': 'keyword'
+ }
+ }],
+ { include: '@whitespace' },
+ ['[{}()\\[\\]]', '@brackets'],
+ ['#+\\d', 'number.arg'],
+ ['\\-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)\\s*(?:em|ex|pt|pc|sp|cm|mm|in)', 'number.len']
+ ],
+ whitespace: [
+ ['[ \\t\\r\\n]+', 'white'],
+ ['%.*$', 'comment']
+ ]
+ }
+ })
+}
diff --git a/src/renderer/others/premium.ts b/src/renderer/others/premium.ts
new file mode 100644
index 000000000..1c79217c6
--- /dev/null
+++ b/src/renderer/others/premium.ts
@@ -0,0 +1,294 @@
+import { LicenseToken } from 'app-license'
+import { PREMIUM_PUBLIC_KEY } from '@share/misc'
+import { getActionHandler } from '@fe/core/action'
+import * as api from '@fe/support/api'
+import { getSetting, setSetting } from '@fe/services/setting'
+import { refresh } from '@fe/services/view'
+import { FLAG_DEMO, FLAG_MAS, MODE } from '@fe/support/args'
+import ga from '@fe/support/ga'
+import { getLogger, md5 } from '@fe/utils'
+import { registerHook, triggerHook } from '@fe/core/hook'
+import { useToast } from '@fe/support/ui/toast'
+import type { PremiumTab } from '@fe/types'
+import { getCurrentLanguage } from '@fe/services/i18n'
+
+const tokenPrefix = 'ynkv2:'
+const logger = getLogger('premium')
+
+let lastPurchased: boolean | undefined
+let licenseToken: LicenseToken | null | undefined
+let upgradeTryCount = 0
+
+type Payload = {
+ fetchToken: { licenseId: string }
+ removeDevice: { licenseId: string, device: string }
+ addDevice: { licenseId: string }
+ fetchDevices: { licenseId: string }
+ upgradeLicense: { oldLicense: string, locale: string }
+ checkDevice: { device: string }
+ genDeviceString: {},
+}
+
+export async function requestApi (method: T, payload: Payload[T]) {
+ const { data } = await api.fetchHttp('/api/premium', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ method, payload }),
+ })
+
+ return data
+}
+
+async function fetchToken (licenseId: string) {
+ const token = await requestApi('fetchToken', { licenseId })
+ return new LicenseToken(token, { publicOrPrivateKey: PREMIUM_PUBLIC_KEY })
+}
+
+function syncCacheLicenseToken (token: LicenseToken | null) {
+ logger.debug('syncCacheLicenseToken', !!token)
+ const oldToken = licenseToken
+ licenseToken = token
+
+ if (oldToken?.status !== token?.status) {
+ refresh()
+ }
+
+ return licenseToken
+}
+
+export function tokenAvailableDays (token: LicenseToken) {
+ return Math.floor((token.expires.getTime() - Date.now()) / 1000 / 60 / 60 / 24)
+}
+
+export function tokenIsExpiredSoon (token: LicenseToken) {
+ if (FLAG_MAS) {
+ return false
+ }
+
+ const days = tokenAvailableDays(token)
+
+ return days <= 3 && days >= 0
+}
+
+export function tokenIsStaleSoon (token: LicenseToken) {
+ if (token.status === 'stale') {
+ return false
+ }
+
+ if (!token.fetchedAt.getTime()) {
+ return true
+ }
+
+ // if fetched at 25 days ago, it's stale soon
+ // if (token.fetchedAt.getTime() < Date.now() - 1000 * 60 * 60 * 24 * 25) {
+ // return true
+ // }
+
+ return false
+}
+
+async function upgradeV1License (oldLicense: string) {
+ logger.debug('upgradeV1License', oldLicense)
+ if (licenseToken) {
+ return
+ }
+
+ if (upgradeTryCount >= 1) {
+ return
+ }
+
+ upgradeTryCount++
+
+ try {
+ const licenseId = await requestApi('upgradeLicense', { oldLicense, locale: getCurrentLanguage() })
+ await activateLicense(licenseId)
+ useToast().show('info', 'License upgraded successfully')
+ showPremium('activation')
+ } catch (error) {
+ useToast().show('warning', `License upgrade failed, please contact support [${error}]`, 6000)
+ }
+}
+
+function _getPurchased (force = false) {
+ logger.debug('_getPurchased', force)
+ if (FLAG_DEMO || MODE === 'share-preview') {
+ return true
+ }
+
+ let token = licenseToken
+ if (typeof token === 'undefined' || force) {
+ token = getLicenseToken()
+ }
+
+ return !!(token?.isAvailable)
+}
+
+export function getPurchased (force = false) {
+ const val = _getPurchased(force)
+
+ if (typeof lastPurchased === 'boolean' && val !== lastPurchased) {
+ lastPurchased = val
+ triggerHook('PREMIUM_STATUS_CHANGED')
+ } else {
+ lastPurchased = val
+ }
+
+ return val
+}
+
+export function showPremium (tab?: PremiumTab) {
+ logger.debug('showPremium', tab)
+ upgradeTryCount = 0
+ getActionHandler('premium.show')(tab)
+ ga.logEvent('yn_premium_show', { purchased: getPurchased() })
+}
+
+export function getLicenseToken () {
+ logger.debug('getLicenseToken')
+ try {
+ const tokenStr = getSetting('license')
+ if (!tokenStr) {
+ return syncCacheLicenseToken(null)
+ }
+
+ if (!tokenStr.startsWith(tokenPrefix)) {
+ upgradeV1License(tokenStr)
+ return syncCacheLicenseToken(null)
+ }
+
+ const token = new LicenseToken(
+ tokenStr.slice(tokenPrefix.length),
+ { publicOrPrivateKey: PREMIUM_PUBLIC_KEY }
+ )
+
+ ga.setUserProperties({
+ expires: token.expires.toLocaleDateString(),
+ hash: md5(token.licenseId),
+ })
+
+ return syncCacheLicenseToken(token)
+ } catch (error) {
+ logger.error('getLicenseToken', error)
+ }
+
+ return syncCacheLicenseToken(null)
+}
+
+export async function cleanLicense () {
+ logger.debug('cleanLicense')
+ // do not clean old license
+ if (!getSetting('license', '').startsWith(tokenPrefix)) {
+ return
+ }
+
+ await setSetting('license', '')
+}
+
+async function setLicense (licenseId: string) {
+ logger.debug('setLicense', licenseId)
+ try {
+ if (!licenseId) {
+ return
+ }
+
+ try {
+ const token = await fetchToken(licenseId)
+
+ if (!token.isAvailable) {
+ throw new Error(`Error, license status [${token.status}]`)
+ }
+
+ await setSetting('license', tokenPrefix + token.toString())
+ } catch (error: any) {
+ if (error.message === 'DEVICE_NOT_FOUND' || error.message === 'INVALID_LICENSE') {
+ await cleanLicense()
+ }
+
+ throw error
+ }
+ } catch (error: any) {
+ logger.error('setLicense', error)
+ throw error
+ } finally {
+ getPurchased(true)
+ }
+}
+
+async function checkDevice (device: string) {
+ try {
+ await requestApi('checkDevice', { device })
+ } catch (error) {
+ cleanLicense()
+ throw error
+ }
+}
+
+export async function refreshLicense (opts?: { throwError?: boolean }) {
+ logger.debug('refreshLicense', opts)
+ try {
+ const token = getLicenseToken()
+ if (token) {
+ await checkDevice(token.device)
+ await setLicense(token.licenseId)
+ }
+ } catch (error) {
+ if (opts?.throwError) {
+ throw error
+ } else {
+ logger.error('refreshLicense', error)
+ }
+ }
+}
+
+export async function activateLicense (licenseId: string) {
+ logger.debug('activateLicense', licenseId)
+ await requestApi('addDevice', { licenseId })
+ await setLicense(licenseId)
+}
+
+export async function activateByTokenString (tokenString: string) {
+ logger.debug('activateByToken', tokenString)
+ await setSetting('license', tokenPrefix + tokenString)
+ const token = getLicenseToken()
+ if (token) {
+ await checkDevice(token.device)
+ } else {
+ throw new Error('INVALID_LICENSE')
+ }
+}
+
+function checkLicenseStatus () {
+ logger.debug('checkLicenseStatus')
+ const token = getLicenseToken()
+ if (token) {
+ if (token.status === 'stale') {
+ useToast().show('warning', 'License unrecognized, please refresh')
+ showPremium('activation')
+ } else if (token.status === 'expired') {
+ useToast().show('warning', 'License expired, please renew')
+ showPremium('activation')
+ } else if (tokenIsStaleSoon(token)) {
+ useToast().show('warning', 'License unrecognized, please refresh')
+ showPremium('activation')
+ } else if (tokenIsExpiredSoon(token)) {
+ useToast().show('warning', 'License expires soon, please renew')
+ showPremium('activation')
+ }
+ }
+}
+
+async function refreshAndCheckLicenseStatus () {
+ if (FLAG_DEMO || MODE === 'share-preview') {
+ return
+ }
+
+ logger.debug('refreshAndCheckLicenseStatus')
+ try {
+ await refreshLicense()
+ } finally {
+ checkLicenseStatus()
+ }
+}
+
+registerHook('STARTUP', refreshAndCheckLicenseStatus)
+setInterval(refreshAndCheckLicenseStatus, 1000 * 60 * 60 * 6) // 6 hours
diff --git a/src/renderer/others/prism-languages-all.ts b/src/renderer/others/prism-languages-all.ts
new file mode 100644
index 000000000..116048901
--- /dev/null
+++ b/src/renderer/others/prism-languages-all.ts
@@ -0,0 +1,297 @@
+import 'prismjs/components/prism-markup'
+import 'prismjs/components/prism-css'
+import 'prismjs/components/prism-clike'
+import 'prismjs/components/prism-regex'
+import 'prismjs/components/prism-javascript'
+import 'prismjs/components/prism-abap'
+import 'prismjs/components/prism-abnf'
+import 'prismjs/components/prism-actionscript'
+import 'prismjs/components/prism-ada'
+import 'prismjs/components/prism-agda'
+import 'prismjs/components/prism-al'
+import 'prismjs/components/prism-antlr4'
+import 'prismjs/components/prism-apacheconf'
+import 'prismjs/components/prism-sql'
+import 'prismjs/components/prism-apex'
+import 'prismjs/components/prism-apl'
+import 'prismjs/components/prism-applescript'
+import 'prismjs/components/prism-aql'
+import 'prismjs/components/prism-c'
+import 'prismjs/components/prism-cpp'
+import 'prismjs/components/prism-arduino'
+import 'prismjs/components/prism-arff'
+import 'prismjs/components/prism-armasm'
+import 'prismjs/components/prism-bash'
+import 'prismjs/components/prism-yaml'
+import 'prismjs/components/prism-markdown'
+import 'prismjs/components/prism-arturo'
+import 'prismjs/components/prism-asciidoc'
+import 'prismjs/components/prism-csharp'
+import 'prismjs/components/prism-aspnet'
+import 'prismjs/components/prism-asm6502'
+import 'prismjs/components/prism-asmatmel'
+import 'prismjs/components/prism-autohotkey'
+import 'prismjs/components/prism-autoit'
+import 'prismjs/components/prism-avisynth'
+import 'prismjs/components/prism-avro-idl'
+import 'prismjs/components/prism-awk'
+import 'prismjs/components/prism-basic'
+import 'prismjs/components/prism-batch'
+import 'prismjs/components/prism-bbcode'
+import 'prismjs/components/prism-bbj'
+import 'prismjs/components/prism-bicep'
+import 'prismjs/components/prism-birb'
+import 'prismjs/components/prism-bison'
+import 'prismjs/components/prism-bnf'
+import 'prismjs/components/prism-bqn'
+import 'prismjs/components/prism-brainfuck'
+import 'prismjs/components/prism-brightscript'
+import 'prismjs/components/prism-bro'
+import 'prismjs/components/prism-bsl'
+import 'prismjs/components/prism-cfscript'
+import 'prismjs/components/prism-chaiscript'
+import 'prismjs/components/prism-cil'
+import 'prismjs/components/prism-cilkc'
+import 'prismjs/components/prism-cilkcpp'
+import 'prismjs/components/prism-clojure'
+import 'prismjs/components/prism-cmake'
+import 'prismjs/components/prism-cobol'
+import 'prismjs/components/prism-coffeescript'
+import 'prismjs/components/prism-concurnas'
+import 'prismjs/components/prism-csp'
+import 'prismjs/components/prism-cooklang'
+import 'prismjs/components/prism-coq'
+import 'prismjs/components/prism-ruby'
+import 'prismjs/components/prism-crystal'
+import 'prismjs/components/prism-css-extras'
+import 'prismjs/components/prism-csv'
+import 'prismjs/components/prism-cue'
+import 'prismjs/components/prism-cypher'
+import 'prismjs/components/prism-d'
+import 'prismjs/components/prism-dart'
+import 'prismjs/components/prism-dataweave'
+import 'prismjs/components/prism-dax'
+import 'prismjs/components/prism-dhall'
+import 'prismjs/components/prism-diff'
+import 'prismjs/components/prism-markup-templating'
+import 'prismjs/components/prism-django'
+import 'prismjs/components/prism-dns-zone-file'
+import 'prismjs/components/prism-docker'
+import 'prismjs/components/prism-dot'
+import 'prismjs/components/prism-ebnf'
+import 'prismjs/components/prism-editorconfig'
+import 'prismjs/components/prism-eiffel'
+import 'prismjs/components/prism-ejs'
+import 'prismjs/components/prism-elixir'
+import 'prismjs/components/prism-elm'
+import 'prismjs/components/prism-lua'
+import 'prismjs/components/prism-etlua'
+import 'prismjs/components/prism-erb'
+import 'prismjs/components/prism-erlang'
+import 'prismjs/components/prism-excel-formula'
+import 'prismjs/components/prism-fsharp'
+import 'prismjs/components/prism-factor'
+import 'prismjs/components/prism-false'
+import 'prismjs/components/prism-firestore-security-rules'
+import 'prismjs/components/prism-flow'
+import 'prismjs/components/prism-fortran'
+import 'prismjs/components/prism-ftl'
+import 'prismjs/components/prism-gml'
+import 'prismjs/components/prism-gap'
+import 'prismjs/components/prism-gcode'
+import 'prismjs/components/prism-gdscript'
+import 'prismjs/components/prism-gedcom'
+import 'prismjs/components/prism-gettext'
+import 'prismjs/components/prism-gherkin'
+import 'prismjs/components/prism-git'
+import 'prismjs/components/prism-glsl'
+import 'prismjs/components/prism-gn'
+import 'prismjs/components/prism-linker-script'
+import 'prismjs/components/prism-go'
+import 'prismjs/components/prism-go-module'
+import 'prismjs/components/prism-gradle'
+import 'prismjs/components/prism-graphql'
+import 'prismjs/components/prism-groovy'
+import 'prismjs/components/prism-less'
+import 'prismjs/components/prism-scss'
+import 'prismjs/components/prism-textile'
+import 'prismjs/components/prism-haml'
+import 'prismjs/components/prism-handlebars'
+import 'prismjs/components/prism-haskell'
+import 'prismjs/components/prism-haxe'
+import 'prismjs/components/prism-hcl'
+import 'prismjs/components/prism-hlsl'
+import 'prismjs/components/prism-hoon'
+import 'prismjs/components/prism-hpkp'
+import 'prismjs/components/prism-hsts'
+import 'prismjs/components/prism-json'
+import 'prismjs/components/prism-uri'
+import 'prismjs/components/prism-http'
+import 'prismjs/components/prism-ichigojam'
+import 'prismjs/components/prism-icon'
+import 'prismjs/components/prism-icu-message-format'
+import 'prismjs/components/prism-idris'
+import 'prismjs/components/prism-ignore'
+import 'prismjs/components/prism-inform7'
+import 'prismjs/components/prism-ini'
+import 'prismjs/components/prism-io'
+import 'prismjs/components/prism-j'
+import 'prismjs/components/prism-java'
+import 'prismjs/components/prism-php'
+import 'prismjs/components/prism-javadoclike'
+import 'prismjs/components/prism-scala'
+import 'prismjs/components/prism-javadoc'
+import 'prismjs/components/prism-javastacktrace'
+import 'prismjs/components/prism-jexl'
+import 'prismjs/components/prism-jolie'
+import 'prismjs/components/prism-jq'
+import 'prismjs/components/prism-js-templates'
+import 'prismjs/components/prism-typescript'
+import 'prismjs/components/prism-jsdoc'
+import 'prismjs/components/prism-n4js'
+import 'prismjs/components/prism-js-extras'
+import 'prismjs/components/prism-json5'
+import 'prismjs/components/prism-jsonp'
+import 'prismjs/components/prism-jsstacktrace'
+import 'prismjs/components/prism-julia'
+import 'prismjs/components/prism-keepalived'
+import 'prismjs/components/prism-keyman'
+import 'prismjs/components/prism-kotlin'
+import 'prismjs/components/prism-kumir'
+import 'prismjs/components/prism-kusto'
+import 'prismjs/components/prism-latex'
+import 'prismjs/components/prism-latte'
+import 'prismjs/components/prism-scheme'
+import 'prismjs/components/prism-lilypond'
+import 'prismjs/components/prism-liquid'
+import 'prismjs/components/prism-lisp'
+import 'prismjs/components/prism-livescript'
+import 'prismjs/components/prism-llvm'
+import 'prismjs/components/prism-log'
+import 'prismjs/components/prism-lolcode'
+import 'prismjs/components/prism-magma'
+import 'prismjs/components/prism-makefile'
+import 'prismjs/components/prism-mata'
+import 'prismjs/components/prism-matlab'
+import 'prismjs/components/prism-maxscript'
+import 'prismjs/components/prism-mel'
+import 'prismjs/components/prism-mermaid'
+import 'prismjs/components/prism-metafont'
+import 'prismjs/components/prism-mizar'
+import 'prismjs/components/prism-mongodb'
+import 'prismjs/components/prism-monkey'
+import 'prismjs/components/prism-moonscript'
+import 'prismjs/components/prism-n1ql'
+import 'prismjs/components/prism-nand2tetris-hdl'
+import 'prismjs/components/prism-naniscript'
+import 'prismjs/components/prism-nasm'
+import 'prismjs/components/prism-neon'
+import 'prismjs/components/prism-nevod'
+import 'prismjs/components/prism-nginx'
+import 'prismjs/components/prism-nim'
+import 'prismjs/components/prism-nix'
+import 'prismjs/components/prism-nsis'
+import 'prismjs/components/prism-objectivec'
+import 'prismjs/components/prism-ocaml'
+import 'prismjs/components/prism-odin'
+import 'prismjs/components/prism-opencl'
+import 'prismjs/components/prism-openqasm'
+import 'prismjs/components/prism-oz'
+import 'prismjs/components/prism-parigp'
+import 'prismjs/components/prism-parser'
+import 'prismjs/components/prism-pascal'
+import 'prismjs/components/prism-pascaligo'
+import 'prismjs/components/prism-psl'
+import 'prismjs/components/prism-pcaxis'
+import 'prismjs/components/prism-peoplecode'
+import 'prismjs/components/prism-perl'
+import 'prismjs/components/prism-phpdoc'
+import 'prismjs/components/prism-php-extras'
+import 'prismjs/components/prism-plant-uml'
+import 'prismjs/components/prism-plsql'
+import 'prismjs/components/prism-powerquery'
+import 'prismjs/components/prism-powershell'
+import 'prismjs/components/prism-processing'
+import 'prismjs/components/prism-prolog'
+import 'prismjs/components/prism-promql'
+import 'prismjs/components/prism-properties'
+import 'prismjs/components/prism-protobuf'
+import 'prismjs/components/prism-stylus'
+import 'prismjs/components/prism-twig'
+import 'prismjs/components/prism-pug'
+import 'prismjs/components/prism-puppet'
+import 'prismjs/components/prism-pure'
+import 'prismjs/components/prism-purebasic'
+import 'prismjs/components/prism-purescript'
+import 'prismjs/components/prism-python'
+import 'prismjs/components/prism-qsharp'
+import 'prismjs/components/prism-q'
+import 'prismjs/components/prism-qml'
+import 'prismjs/components/prism-qore'
+import 'prismjs/components/prism-r'
+import 'prismjs/components/prism-racket'
+import 'prismjs/components/prism-cshtml'
+import 'prismjs/components/prism-jsx'
+import 'prismjs/components/prism-tsx'
+import 'prismjs/components/prism-reason'
+import 'prismjs/components/prism-rego'
+import 'prismjs/components/prism-renpy'
+import 'prismjs/components/prism-rescript'
+import 'prismjs/components/prism-rest'
+import 'prismjs/components/prism-rip'
+import 'prismjs/components/prism-roboconf'
+import 'prismjs/components/prism-robotframework'
+import 'prismjs/components/prism-rust'
+import 'prismjs/components/prism-sas'
+import 'prismjs/components/prism-sass'
+import 'prismjs/components/prism-shell-session'
+import 'prismjs/components/prism-smali'
+import 'prismjs/components/prism-smalltalk'
+import 'prismjs/components/prism-smarty'
+import 'prismjs/components/prism-sml'
+import 'prismjs/components/prism-solidity'
+import 'prismjs/components/prism-solution-file'
+import 'prismjs/components/prism-soy'
+import 'prismjs/components/prism-turtle'
+import 'prismjs/components/prism-sparql'
+import 'prismjs/components/prism-splunk-spl'
+import 'prismjs/components/prism-sqf'
+import 'prismjs/components/prism-squirrel'
+import 'prismjs/components/prism-stan'
+import 'prismjs/components/prism-stata'
+import 'prismjs/components/prism-iecst'
+import 'prismjs/components/prism-supercollider'
+import 'prismjs/components/prism-swift'
+import 'prismjs/components/prism-systemd'
+import 'prismjs/components/prism-t4-templating'
+import 'prismjs/components/prism-t4-cs'
+import 'prismjs/components/prism-vbnet'
+import 'prismjs/components/prism-t4-vb'
+import 'prismjs/components/prism-tap'
+import 'prismjs/components/prism-tcl'
+import 'prismjs/components/prism-tt2'
+import 'prismjs/components/prism-toml'
+import 'prismjs/components/prism-tremor'
+import 'prismjs/components/prism-typoscript'
+import 'prismjs/components/prism-unrealscript'
+import 'prismjs/components/prism-uorazor'
+import 'prismjs/components/prism-v'
+import 'prismjs/components/prism-vala'
+import 'prismjs/components/prism-velocity'
+import 'prismjs/components/prism-verilog'
+import 'prismjs/components/prism-vhdl'
+import 'prismjs/components/prism-vim'
+import 'prismjs/components/prism-visual-basic'
+import 'prismjs/components/prism-warpscript'
+import 'prismjs/components/prism-wasm'
+import 'prismjs/components/prism-web-idl'
+import 'prismjs/components/prism-wgsl'
+import 'prismjs/components/prism-wiki'
+import 'prismjs/components/prism-wolfram'
+import 'prismjs/components/prism-wren'
+import 'prismjs/components/prism-xeora'
+import 'prismjs/components/prism-xml-doc'
+import 'prismjs/components/prism-xojo'
+import 'prismjs/components/prism-xquery'
+import 'prismjs/components/prism-yang'
+import 'prismjs/components/prism-zig'
diff --git a/src/renderer/others/prism-style.scss b/src/renderer/others/prism-style.scss
new file mode 100644
index 000000000..7e911d497
--- /dev/null
+++ b/src/renderer/others/prism-style.scss
@@ -0,0 +1,25 @@
+@use 'sass:meta';
+@use '@fe/styles/mixins.scss' as *;
+@import 'prismjs/themes/prism.css';
+
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+ background: none;
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+ text-shadow: none;
+ background: var(--selection-color);
+}
+
+@include dark-theme {
+ code[class*="language-"], pre[class*="language-"] {
+ text-shadow: none;
+ }
+
+ @include meta.load-css('prismjs/themes/prism-tomorrow');
+}
diff --git a/src/renderer/others/semver.js b/src/renderer/others/semver.js
new file mode 100644
index 000000000..5a2980036
--- /dev/null
+++ b/src/renderer/others/semver.js
@@ -0,0 +1,2373 @@
+/**
+ * node-semver https://github.com/npm/node-semve
+ * this file generate by vite
+ * fix semver not work using vite
+ */
+
+ var __create = Object.create;
+ var __defProp = Object.defineProperty;
+ var __defProps = Object.defineProperties;
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+ var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+ var __getOwnPropNames = Object.getOwnPropertyNames;
+ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+ var __getProtoOf = Object.getPrototypeOf;
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
+ var __propIsEnum = Object.prototype.propertyIsEnumerable;
+ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+ var __spreadValues = (a, b) => {
+ for (var prop in b || (b = {}))
+ if (__hasOwnProp.call(b, prop))
+ __defNormalProp(a, prop, b[prop]);
+ if (__getOwnPropSymbols)
+ for (var prop of __getOwnPropSymbols(b)) {
+ if (__propIsEnum.call(b, prop))
+ __defNormalProp(a, prop, b[prop]);
+ }
+ return a;
+ };
+ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+ get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+ }) : x)(function(x) {
+ if (typeof require !== "undefined")
+ return require.apply(this, arguments);
+ throw new Error('Dynamic require of "' + x + '" is not supported');
+ });
+ var __esm = (fn, res) => function __init() {
+ return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+ };
+ var __commonJS = (cb, mod) => function __require2() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+ };
+ var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+ };
+ var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+ };
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+ // node_modules/semver/internal/constants.js
+ var require_constants = __commonJS({
+ "node_modules/semver/internal/constants.js"(exports, module) {
+ var SEMVER_SPEC_VERSION = "2.0.0";
+ var MAX_LENGTH = 256;
+ var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+ var MAX_SAFE_COMPONENT_LENGTH = 16;
+ module.exports = {
+ SEMVER_SPEC_VERSION,
+ MAX_LENGTH,
+ MAX_SAFE_INTEGER,
+ MAX_SAFE_COMPONENT_LENGTH
+ };
+ }
+ });
+
+ // node_modules/semver/internal/debug.js
+ var require_debug = __commonJS({
+ "node_modules/semver/internal/debug.js"(exports, module) {
+ var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+ };
+ module.exports = debug;
+ }
+ });
+
+ // node_modules/semver/internal/re.js
+ var require_re = __commonJS({
+ "node_modules/semver/internal/re.js"(exports, module) {
+ var { MAX_SAFE_COMPONENT_LENGTH } = require_constants();
+ var debug = require_debug();
+ exports = module.exports = {};
+ var re = exports.re = [];
+ var src = exports.src = [];
+ var t = exports.t = {};
+ var R = 0;
+ var createToken = (name, value, isGlobal) => {
+ const index = R++;
+ debug(name, index, value);
+ t[name] = index;
+ src[index] = value;
+ re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+ };
+ createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+ createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+");
+ createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*");
+ createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+ createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+ createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+ createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+ createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+");
+ createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+ createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+ createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+ createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+ createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+ createToken("GTLT", "((?:<|>)?=?)");
+ createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+ createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+ createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+ createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+ createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+ createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`);
+ createToken("COERCERTL", src[t.COERCE], true);
+ createToken("LONETILDE", "(?:~>?)");
+ createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+ exports.tildeTrimReplace = "$1~";
+ createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+ createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("LONECARET", "(?:\\^)");
+ createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+ exports.caretTrimReplace = "$1^";
+ createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+ createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+ createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+ createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+ exports.comparatorTrimReplace = "$1$2$3";
+ createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+ createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+ createToken("STAR", "(<|>)?=?\\s*\\*");
+ createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+ createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+ }
+ });
+
+ // node_modules/semver/internal/parse-options.js
+ var require_parse_options = __commonJS({
+ "node_modules/semver/internal/parse-options.js"(exports, module) {
+ var opts = ["includePrerelease", "loose", "rtl"];
+ var parseOptions = (options) => !options ? {} : typeof options !== "object" ? { loose: true } : opts.filter((k) => options[k]).reduce((o, k) => {
+ o[k] = true;
+ return o;
+ }, {});
+ module.exports = parseOptions;
+ }
+ });
+
+ // node_modules/semver/internal/identifiers.js
+ var require_identifiers = __commonJS({
+ "node_modules/semver/internal/identifiers.js"(exports, module) {
+ var numeric = /^[0-9]+$/;
+ var compareIdentifiers = (a, b) => {
+ const anum = numeric.test(a);
+ const bnum = numeric.test(b);
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+ return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+ };
+ var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+ module.exports = {
+ compareIdentifiers,
+ rcompareIdentifiers
+ };
+ }
+ });
+
+ // node_modules/semver/classes/semver.js
+ var require_semver = __commonJS({
+ "node_modules/semver/classes/semver.js"(exports, module) {
+ var debug = require_debug();
+ var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+ var { re, t } = require_re();
+ var parseOptions = require_parse_options();
+ var { compareIdentifiers } = require_identifiers();
+ var SemVer = class {
+ constructor(version, options) {
+ options = parseOptions(options);
+ if (version instanceof SemVer) {
+ if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+ return version;
+ } else {
+ version = version.version;
+ }
+ } else if (typeof version !== "string") {
+ throw new TypeError(`Invalid Version: ${version}`);
+ }
+ if (version.length > MAX_LENGTH) {
+ throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+ }
+ debug("SemVer", version, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+ const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+ if (!m) {
+ throw new TypeError(`Invalid Version: ${version}`);
+ }
+ this.raw = version;
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+ throw new TypeError("Invalid major version");
+ }
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+ throw new TypeError("Invalid minor version");
+ }
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+ throw new TypeError("Invalid patch version");
+ }
+ if (!m[4]) {
+ this.prerelease = [];
+ } else {
+ this.prerelease = m[4].split(".").map((id) => {
+ if (/^[0-9]+$/.test(id)) {
+ const num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER) {
+ return num;
+ }
+ }
+ return id;
+ });
+ }
+ this.build = m[5] ? m[5].split(".") : [];
+ this.format();
+ }
+ format() {
+ this.version = `${this.major}.${this.minor}.${this.patch}`;
+ if (this.prerelease.length) {
+ this.version += `-${this.prerelease.join(".")}`;
+ }
+ return this.version;
+ }
+ toString() {
+ return this.version;
+ }
+ compare(other) {
+ debug("SemVer.compare", this.version, this.options, other);
+ if (!(other instanceof SemVer)) {
+ if (typeof other === "string" && other === this.version) {
+ return 0;
+ }
+ other = new SemVer(other, this.options);
+ }
+ if (other.version === this.version) {
+ return 0;
+ }
+ return this.compareMain(other) || this.comparePre(other);
+ }
+ compareMain(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+ }
+ comparePre(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ if (this.prerelease.length && !other.prerelease.length) {
+ return -1;
+ } else if (!this.prerelease.length && other.prerelease.length) {
+ return 1;
+ } else if (!this.prerelease.length && !other.prerelease.length) {
+ return 0;
+ }
+ let i = 0;
+ do {
+ const a = this.prerelease[i];
+ const b = other.prerelease[i];
+ debug("prerelease compare", i, a, b);
+ if (a === void 0 && b === void 0) {
+ return 0;
+ } else if (b === void 0) {
+ return 1;
+ } else if (a === void 0) {
+ return -1;
+ } else if (a === b) {
+ continue;
+ } else {
+ return compareIdentifiers(a, b);
+ }
+ } while (++i);
+ }
+ compareBuild(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ let i = 0;
+ do {
+ const a = this.build[i];
+ const b = other.build[i];
+ debug("prerelease compare", i, a, b);
+ if (a === void 0 && b === void 0) {
+ return 0;
+ } else if (b === void 0) {
+ return 1;
+ } else if (a === void 0) {
+ return -1;
+ } else if (a === b) {
+ continue;
+ } else {
+ return compareIdentifiers(a, b);
+ }
+ } while (++i);
+ }
+ inc(release, identifier) {
+ switch (release) {
+ case "premajor":
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc("pre", identifier);
+ break;
+ case "preminor":
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc("pre", identifier);
+ break;
+ case "prepatch":
+ this.prerelease.length = 0;
+ this.inc("patch", identifier);
+ this.inc("pre", identifier);
+ break;
+ case "prerelease":
+ if (this.prerelease.length === 0) {
+ this.inc("patch", identifier);
+ }
+ this.inc("pre", identifier);
+ break;
+ case "major":
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+ this.major++;
+ }
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case "minor":
+ if (this.patch !== 0 || this.prerelease.length === 0) {
+ this.minor++;
+ }
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case "patch":
+ if (this.prerelease.length === 0) {
+ this.patch++;
+ }
+ this.prerelease = [];
+ break;
+ case "pre":
+ if (this.prerelease.length === 0) {
+ this.prerelease = [0];
+ } else {
+ let i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === "number") {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) {
+ this.prerelease.push(0);
+ }
+ }
+ if (identifier) {
+ if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+ if (isNaN(this.prerelease[1])) {
+ this.prerelease = [identifier, 0];
+ }
+ } else {
+ this.prerelease = [identifier, 0];
+ }
+ }
+ break;
+ default:
+ throw new Error(`invalid increment argument: ${release}`);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+ }
+ };
+ module.exports = SemVer;
+ }
+ });
+
+ // node_modules/semver/functions/parse.js
+ var require_parse = __commonJS({
+ "node_modules/semver/functions/parse.js"(exports, module) {
+ var { MAX_LENGTH } = require_constants();
+ var { re, t } = require_re();
+ var SemVer = require_semver();
+ var parseOptions = require_parse_options();
+ var parse = (version, options) => {
+ options = parseOptions(options);
+ if (version instanceof SemVer) {
+ return version;
+ }
+ if (typeof version !== "string") {
+ return null;
+ }
+ if (version.length > MAX_LENGTH) {
+ return null;
+ }
+ const r = options.loose ? re[t.LOOSE] : re[t.FULL];
+ if (!r.test(version)) {
+ return null;
+ }
+ try {
+ return new SemVer(version, options);
+ } catch (er) {
+ return null;
+ }
+ };
+ module.exports = parse;
+ }
+ });
+
+ // node_modules/semver/functions/valid.js
+ var require_valid = __commonJS({
+ "node_modules/semver/functions/valid.js"(exports, module) {
+ var parse = require_parse();
+ var valid = (version, options) => {
+ const v = parse(version, options);
+ return v ? v.version : null;
+ };
+ module.exports = valid;
+ }
+ });
+
+ // node_modules/semver/functions/clean.js
+ var require_clean = __commonJS({
+ "node_modules/semver/functions/clean.js"(exports, module) {
+ var parse = require_parse();
+ var clean = (version, options) => {
+ const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+ return s ? s.version : null;
+ };
+ module.exports = clean;
+ }
+ });
+
+ // node_modules/semver/functions/inc.js
+ var require_inc = __commonJS({
+ "node_modules/semver/functions/inc.js"(exports, module) {
+ var SemVer = require_semver();
+ var inc = (version, release, options, identifier) => {
+ if (typeof options === "string") {
+ identifier = options;
+ options = void 0;
+ }
+ try {
+ return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+ };
+ module.exports = inc;
+ }
+ });
+
+ // node_modules/semver/functions/compare.js
+ var require_compare = __commonJS({
+ "node_modules/semver/functions/compare.js"(exports, module) {
+ var SemVer = require_semver();
+ var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+ module.exports = compare;
+ }
+ });
+
+ // node_modules/semver/functions/eq.js
+ var require_eq = __commonJS({
+ "node_modules/semver/functions/eq.js"(exports, module) {
+ var compare = require_compare();
+ var eq = (a, b, loose) => compare(a, b, loose) === 0;
+ module.exports = eq;
+ }
+ });
+
+ // node_modules/semver/functions/diff.js
+ var require_diff = __commonJS({
+ "node_modules/semver/functions/diff.js"(exports, module) {
+ var parse = require_parse();
+ var eq = require_eq();
+ var diff = (version1, version2) => {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ const v1 = parse(version1);
+ const v2 = parse(version2);
+ const hasPre = v1.prerelease.length || v2.prerelease.length;
+ const prefix = hasPre ? "pre" : "";
+ const defaultResult = hasPre ? "prerelease" : "";
+ for (const key in v1) {
+ if (key === "major" || key === "minor" || key === "patch") {
+ if (v1[key] !== v2[key]) {
+ return prefix + key;
+ }
+ }
+ }
+ return defaultResult;
+ }
+ };
+ module.exports = diff;
+ }
+ });
+
+ // node_modules/semver/functions/major.js
+ var require_major = __commonJS({
+ "node_modules/semver/functions/major.js"(exports, module) {
+ var SemVer = require_semver();
+ var major = (a, loose) => new SemVer(a, loose).major;
+ module.exports = major;
+ }
+ });
+
+ // node_modules/semver/functions/minor.js
+ var require_minor = __commonJS({
+ "node_modules/semver/functions/minor.js"(exports, module) {
+ var SemVer = require_semver();
+ var minor = (a, loose) => new SemVer(a, loose).minor;
+ module.exports = minor;
+ }
+ });
+
+ // node_modules/semver/functions/patch.js
+ var require_patch = __commonJS({
+ "node_modules/semver/functions/patch.js"(exports, module) {
+ var SemVer = require_semver();
+ var patch = (a, loose) => new SemVer(a, loose).patch;
+ module.exports = patch;
+ }
+ });
+
+ // node_modules/semver/functions/prerelease.js
+ var require_prerelease = __commonJS({
+ "node_modules/semver/functions/prerelease.js"(exports, module) {
+ var parse = require_parse();
+ var prerelease = (version, options) => {
+ const parsed = parse(version, options);
+ return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+ };
+ module.exports = prerelease;
+ }
+ });
+
+ // node_modules/semver/functions/rcompare.js
+ var require_rcompare = __commonJS({
+ "node_modules/semver/functions/rcompare.js"(exports, module) {
+ var compare = require_compare();
+ var rcompare = (a, b, loose) => compare(b, a, loose);
+ module.exports = rcompare;
+ }
+ });
+
+ // node_modules/semver/functions/compare-loose.js
+ var require_compare_loose = __commonJS({
+ "node_modules/semver/functions/compare-loose.js"(exports, module) {
+ var compare = require_compare();
+ var compareLoose = (a, b) => compare(a, b, true);
+ module.exports = compareLoose;
+ }
+ });
+
+ // node_modules/semver/functions/compare-build.js
+ var require_compare_build = __commonJS({
+ "node_modules/semver/functions/compare-build.js"(exports, module) {
+ var SemVer = require_semver();
+ var compareBuild = (a, b, loose) => {
+ const versionA = new SemVer(a, loose);
+ const versionB = new SemVer(b, loose);
+ return versionA.compare(versionB) || versionA.compareBuild(versionB);
+ };
+ module.exports = compareBuild;
+ }
+ });
+
+ // node_modules/semver/functions/sort.js
+ var require_sort = __commonJS({
+ "node_modules/semver/functions/sort.js"(exports, module) {
+ var compareBuild = require_compare_build();
+ var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+ module.exports = sort;
+ }
+ });
+
+ // node_modules/semver/functions/rsort.js
+ var require_rsort = __commonJS({
+ "node_modules/semver/functions/rsort.js"(exports, module) {
+ var compareBuild = require_compare_build();
+ var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+ module.exports = rsort;
+ }
+ });
+
+ // node_modules/semver/functions/gt.js
+ var require_gt = __commonJS({
+ "node_modules/semver/functions/gt.js"(exports, module) {
+ var compare = require_compare();
+ var gt = (a, b, loose) => compare(a, b, loose) > 0;
+ module.exports = gt;
+ }
+ });
+
+ // node_modules/semver/functions/lt.js
+ var require_lt = __commonJS({
+ "node_modules/semver/functions/lt.js"(exports, module) {
+ var compare = require_compare();
+ var lt = (a, b, loose) => compare(a, b, loose) < 0;
+ module.exports = lt;
+ }
+ });
+
+ // node_modules/semver/functions/neq.js
+ var require_neq = __commonJS({
+ "node_modules/semver/functions/neq.js"(exports, module) {
+ var compare = require_compare();
+ var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+ module.exports = neq;
+ }
+ });
+
+ // node_modules/semver/functions/gte.js
+ var require_gte = __commonJS({
+ "node_modules/semver/functions/gte.js"(exports, module) {
+ var compare = require_compare();
+ var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+ module.exports = gte;
+ }
+ });
+
+ // node_modules/semver/functions/lte.js
+ var require_lte = __commonJS({
+ "node_modules/semver/functions/lte.js"(exports, module) {
+ var compare = require_compare();
+ var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+ module.exports = lte;
+ }
+ });
+
+ // node_modules/semver/functions/cmp.js
+ var require_cmp = __commonJS({
+ "node_modules/semver/functions/cmp.js"(exports, module) {
+ var eq = require_eq();
+ var neq = require_neq();
+ var gt = require_gt();
+ var gte = require_gte();
+ var lt = require_lt();
+ var lte = require_lte();
+ var cmp = (a, op, b, loose) => {
+ switch (op) {
+ case "===":
+ if (typeof a === "object") {
+ a = a.version;
+ }
+ if (typeof b === "object") {
+ b = b.version;
+ }
+ return a === b;
+ case "!==":
+ if (typeof a === "object") {
+ a = a.version;
+ }
+ if (typeof b === "object") {
+ b = b.version;
+ }
+ return a !== b;
+ case "":
+ case "=":
+ case "==":
+ return eq(a, b, loose);
+ case "!=":
+ return neq(a, b, loose);
+ case ">":
+ return gt(a, b, loose);
+ case ">=":
+ return gte(a, b, loose);
+ case "<":
+ return lt(a, b, loose);
+ case "<=":
+ return lte(a, b, loose);
+ default:
+ throw new TypeError(`Invalid operator: ${op}`);
+ }
+ };
+ module.exports = cmp;
+ }
+ });
+
+ // node_modules/semver/functions/coerce.js
+ var require_coerce = __commonJS({
+ "node_modules/semver/functions/coerce.js"(exports, module) {
+ var SemVer = require_semver();
+ var parse = require_parse();
+ var { re, t } = require_re();
+ var coerce = (version, options) => {
+ if (version instanceof SemVer) {
+ return version;
+ }
+ if (typeof version === "number") {
+ version = String(version);
+ }
+ if (typeof version !== "string") {
+ return null;
+ }
+ options = options || {};
+ let match = null;
+ if (!options.rtl) {
+ match = version.match(re[t.COERCE]);
+ } else {
+ let next;
+ while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+ if (!match || next.index + next[0].length !== match.index + match[0].length) {
+ match = next;
+ }
+ re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+ }
+ re[t.COERCERTL].lastIndex = -1;
+ }
+ if (match === null) {
+ return null;
+ }
+ return parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
+ };
+ module.exports = coerce;
+ }
+ });
+
+ // node_modules/yallist/iterator.js
+ var require_iterator = __commonJS({
+ "node_modules/yallist/iterator.js"(exports, module) {
+ "use strict";
+ module.exports = function(Yallist) {
+ Yallist.prototype[Symbol.iterator] = function* () {
+ for (let walker = this.head; walker; walker = walker.next) {
+ yield walker.value;
+ }
+ };
+ };
+ }
+ });
+
+ // node_modules/yallist/yallist.js
+ var require_yallist = __commonJS({
+ "node_modules/yallist/yallist.js"(exports, module) {
+ "use strict";
+ module.exports = Yallist;
+ Yallist.Node = Node;
+ Yallist.create = Yallist;
+ function Yallist(list) {
+ var self = this;
+ if (!(self instanceof Yallist)) {
+ self = new Yallist();
+ }
+ self.tail = null;
+ self.head = null;
+ self.length = 0;
+ if (list && typeof list.forEach === "function") {
+ list.forEach(function(item) {
+ self.push(item);
+ });
+ } else if (arguments.length > 0) {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ self.push(arguments[i]);
+ }
+ }
+ return self;
+ }
+ Yallist.prototype.removeNode = function(node) {
+ if (node.list !== this) {
+ throw new Error("removing node which does not belong to this list");
+ }
+ var next = node.next;
+ var prev = node.prev;
+ if (next) {
+ next.prev = prev;
+ }
+ if (prev) {
+ prev.next = next;
+ }
+ if (node === this.head) {
+ this.head = next;
+ }
+ if (node === this.tail) {
+ this.tail = prev;
+ }
+ node.list.length--;
+ node.next = null;
+ node.prev = null;
+ node.list = null;
+ return next;
+ };
+ Yallist.prototype.unshiftNode = function(node) {
+ if (node === this.head) {
+ return;
+ }
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+ var head = this.head;
+ node.list = this;
+ node.next = head;
+ if (head) {
+ head.prev = node;
+ }
+ this.head = node;
+ if (!this.tail) {
+ this.tail = node;
+ }
+ this.length++;
+ };
+ Yallist.prototype.pushNode = function(node) {
+ if (node === this.tail) {
+ return;
+ }
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+ var tail = this.tail;
+ node.list = this;
+ node.prev = tail;
+ if (tail) {
+ tail.next = node;
+ }
+ this.tail = node;
+ if (!this.head) {
+ this.head = node;
+ }
+ this.length++;
+ };
+ Yallist.prototype.push = function() {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ push(this, arguments[i]);
+ }
+ return this.length;
+ };
+ Yallist.prototype.unshift = function() {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ unshift(this, arguments[i]);
+ }
+ return this.length;
+ };
+ Yallist.prototype.pop = function() {
+ if (!this.tail) {
+ return void 0;
+ }
+ var res = this.tail.value;
+ this.tail = this.tail.prev;
+ if (this.tail) {
+ this.tail.next = null;
+ } else {
+ this.head = null;
+ }
+ this.length--;
+ return res;
+ };
+ Yallist.prototype.shift = function() {
+ if (!this.head) {
+ return void 0;
+ }
+ var res = this.head.value;
+ this.head = this.head.next;
+ if (this.head) {
+ this.head.prev = null;
+ } else {
+ this.tail = null;
+ }
+ this.length--;
+ return res;
+ };
+ Yallist.prototype.forEach = function(fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.head, i = 0; walker !== null; i++) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.next;
+ }
+ };
+ Yallist.prototype.forEachReverse = function(fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.prev;
+ }
+ };
+ Yallist.prototype.get = function(n) {
+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+ walker = walker.next;
+ }
+ if (i === n && walker !== null) {
+ return walker.value;
+ }
+ };
+ Yallist.prototype.getReverse = function(n) {
+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+ walker = walker.prev;
+ }
+ if (i === n && walker !== null) {
+ return walker.value;
+ }
+ };
+ Yallist.prototype.map = function(fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.head; walker !== null; ) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.next;
+ }
+ return res;
+ };
+ Yallist.prototype.mapReverse = function(fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.tail; walker !== null; ) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.prev;
+ }
+ return res;
+ };
+ Yallist.prototype.reduce = function(fn, initial) {
+ var acc;
+ var walker = this.head;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.head) {
+ walker = this.head.next;
+ acc = this.head.value;
+ } else {
+ throw new TypeError("Reduce of empty list with no initial value");
+ }
+ for (var i = 0; walker !== null; i++) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.next;
+ }
+ return acc;
+ };
+ Yallist.prototype.reduceReverse = function(fn, initial) {
+ var acc;
+ var walker = this.tail;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.tail) {
+ walker = this.tail.prev;
+ acc = this.tail.value;
+ } else {
+ throw new TypeError("Reduce of empty list with no initial value");
+ }
+ for (var i = this.length - 1; walker !== null; i--) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.prev;
+ }
+ return acc;
+ };
+ Yallist.prototype.toArray = function() {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.head; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.next;
+ }
+ return arr;
+ };
+ Yallist.prototype.toArrayReverse = function() {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.tail; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.prev;
+ }
+ return arr;
+ };
+ Yallist.prototype.slice = function(from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret;
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+ walker = walker.next;
+ }
+ for (; walker !== null && i < to; i++, walker = walker.next) {
+ ret.push(walker.value);
+ }
+ return ret;
+ };
+ Yallist.prototype.sliceReverse = function(from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret;
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+ walker = walker.prev;
+ }
+ for (; walker !== null && i > from; i--, walker = walker.prev) {
+ ret.push(walker.value);
+ }
+ return ret;
+ };
+ Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
+ if (start > this.length) {
+ start = this.length - 1;
+ }
+ if (start < 0) {
+ start = this.length + start;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+ walker = walker.next;
+ }
+ var ret = [];
+ for (var i = 0; walker && i < deleteCount; i++) {
+ ret.push(walker.value);
+ walker = this.removeNode(walker);
+ }
+ if (walker === null) {
+ walker = this.tail;
+ }
+ if (walker !== this.head && walker !== this.tail) {
+ walker = walker.prev;
+ }
+ for (var i = 0; i < nodes.length; i++) {
+ walker = insert(this, walker, nodes[i]);
+ }
+ return ret;
+ };
+ Yallist.prototype.reverse = function() {
+ var head = this.head;
+ var tail = this.tail;
+ for (var walker = head; walker !== null; walker = walker.prev) {
+ var p = walker.prev;
+ walker.prev = walker.next;
+ walker.next = p;
+ }
+ this.head = tail;
+ this.tail = head;
+ return this;
+ };
+ function insert(self, node, value) {
+ var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
+ if (inserted.next === null) {
+ self.tail = inserted;
+ }
+ if (inserted.prev === null) {
+ self.head = inserted;
+ }
+ self.length++;
+ return inserted;
+ }
+ function push(self, item) {
+ self.tail = new Node(item, self.tail, null, self);
+ if (!self.head) {
+ self.head = self.tail;
+ }
+ self.length++;
+ }
+ function unshift(self, item) {
+ self.head = new Node(item, null, self.head, self);
+ if (!self.tail) {
+ self.tail = self.head;
+ }
+ self.length++;
+ }
+ function Node(value, prev, next, list) {
+ if (!(this instanceof Node)) {
+ return new Node(value, prev, next, list);
+ }
+ this.list = list;
+ this.value = value;
+ if (prev) {
+ prev.next = this;
+ this.prev = prev;
+ } else {
+ this.prev = null;
+ }
+ if (next) {
+ next.prev = this;
+ this.next = next;
+ } else {
+ this.next = null;
+ }
+ }
+ try {
+ require_iterator()(Yallist);
+ } catch (er) {
+ }
+ }
+ });
+
+ // node_modules/lru-cache/index.js
+ var require_lru_cache = __commonJS({
+ "node_modules/lru-cache/index.js"(exports, module) {
+ "use strict";
+ var Yallist = require_yallist();
+ var MAX = Symbol("max");
+ var LENGTH = Symbol("length");
+ var LENGTH_CALCULATOR = Symbol("lengthCalculator");
+ var ALLOW_STALE = Symbol("allowStale");
+ var MAX_AGE = Symbol("maxAge");
+ var DISPOSE = Symbol("dispose");
+ var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
+ var LRU_LIST = Symbol("lruList");
+ var CACHE = Symbol("cache");
+ var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
+ var naiveLength = () => 1;
+ var LRUCache = class {
+ constructor(options) {
+ if (typeof options === "number")
+ options = { max: options };
+ if (!options)
+ options = {};
+ if (options.max && (typeof options.max !== "number" || options.max < 0))
+ throw new TypeError("max must be a non-negative number");
+ const max = this[MAX] = options.max || Infinity;
+ const lc = options.length || naiveLength;
+ this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
+ this[ALLOW_STALE] = options.stale || false;
+ if (options.maxAge && typeof options.maxAge !== "number")
+ throw new TypeError("maxAge must be a number");
+ this[MAX_AGE] = options.maxAge || 0;
+ this[DISPOSE] = options.dispose;
+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+ this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+ this.reset();
+ }
+ set max(mL) {
+ if (typeof mL !== "number" || mL < 0)
+ throw new TypeError("max must be a non-negative number");
+ this[MAX] = mL || Infinity;
+ trim(this);
+ }
+ get max() {
+ return this[MAX];
+ }
+ set allowStale(allowStale) {
+ this[ALLOW_STALE] = !!allowStale;
+ }
+ get allowStale() {
+ return this[ALLOW_STALE];
+ }
+ set maxAge(mA) {
+ if (typeof mA !== "number")
+ throw new TypeError("maxAge must be a non-negative number");
+ this[MAX_AGE] = mA;
+ trim(this);
+ }
+ get maxAge() {
+ return this[MAX_AGE];
+ }
+ set lengthCalculator(lC) {
+ if (typeof lC !== "function")
+ lC = naiveLength;
+ if (lC !== this[LENGTH_CALCULATOR]) {
+ this[LENGTH_CALCULATOR] = lC;
+ this[LENGTH] = 0;
+ this[LRU_LIST].forEach((hit) => {
+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+ this[LENGTH] += hit.length;
+ });
+ }
+ trim(this);
+ }
+ get lengthCalculator() {
+ return this[LENGTH_CALCULATOR];
+ }
+ get length() {
+ return this[LENGTH];
+ }
+ get itemCount() {
+ return this[LRU_LIST].length;
+ }
+ rforEach(fn, thisp) {
+ thisp = thisp || this;
+ for (let walker = this[LRU_LIST].tail; walker !== null; ) {
+ const prev = walker.prev;
+ forEachStep(this, fn, walker, thisp);
+ walker = prev;
+ }
+ }
+ forEach(fn, thisp) {
+ thisp = thisp || this;
+ for (let walker = this[LRU_LIST].head; walker !== null; ) {
+ const next = walker.next;
+ forEachStep(this, fn, walker, thisp);
+ walker = next;
+ }
+ }
+ keys() {
+ return this[LRU_LIST].toArray().map((k) => k.key);
+ }
+ values() {
+ return this[LRU_LIST].toArray().map((k) => k.value);
+ }
+ reset() {
+ if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+ this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
+ }
+ this[CACHE] = /* @__PURE__ */ new Map();
+ this[LRU_LIST] = new Yallist();
+ this[LENGTH] = 0;
+ }
+ dump() {
+ return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
+ k: hit.key,
+ v: hit.value,
+ e: hit.now + (hit.maxAge || 0)
+ }).toArray().filter((h) => h);
+ }
+ dumpLru() {
+ return this[LRU_LIST];
+ }
+ set(key, value, maxAge) {
+ maxAge = maxAge || this[MAX_AGE];
+ if (maxAge && typeof maxAge !== "number")
+ throw new TypeError("maxAge must be a number");
+ const now = maxAge ? Date.now() : 0;
+ const len = this[LENGTH_CALCULATOR](value, key);
+ if (this[CACHE].has(key)) {
+ if (len > this[MAX]) {
+ del(this, this[CACHE].get(key));
+ return false;
+ }
+ const node = this[CACHE].get(key);
+ const item = node.value;
+ if (this[DISPOSE]) {
+ if (!this[NO_DISPOSE_ON_SET])
+ this[DISPOSE](key, item.value);
+ }
+ item.now = now;
+ item.maxAge = maxAge;
+ item.value = value;
+ this[LENGTH] += len - item.length;
+ item.length = len;
+ this.get(key);
+ trim(this);
+ return true;
+ }
+ const hit = new Entry(key, value, len, now, maxAge);
+ if (hit.length > this[MAX]) {
+ if (this[DISPOSE])
+ this[DISPOSE](key, value);
+ return false;
+ }
+ this[LENGTH] += hit.length;
+ this[LRU_LIST].unshift(hit);
+ this[CACHE].set(key, this[LRU_LIST].head);
+ trim(this);
+ return true;
+ }
+ has(key) {
+ if (!this[CACHE].has(key))
+ return false;
+ const hit = this[CACHE].get(key).value;
+ return !isStale(this, hit);
+ }
+ get(key) {
+ return get(this, key, true);
+ }
+ peek(key) {
+ return get(this, key, false);
+ }
+ pop() {
+ const node = this[LRU_LIST].tail;
+ if (!node)
+ return null;
+ del(this, node);
+ return node.value;
+ }
+ del(key) {
+ del(this, this[CACHE].get(key));
+ }
+ load(arr) {
+ this.reset();
+ const now = Date.now();
+ for (let l = arr.length - 1; l >= 0; l--) {
+ const hit = arr[l];
+ const expiresAt = hit.e || 0;
+ if (expiresAt === 0)
+ this.set(hit.k, hit.v);
+ else {
+ const maxAge = expiresAt - now;
+ if (maxAge > 0) {
+ this.set(hit.k, hit.v, maxAge);
+ }
+ }
+ }
+ }
+ prune() {
+ this[CACHE].forEach((value, key) => get(this, key, false));
+ }
+ };
+ var get = (self, key, doUse) => {
+ const node = self[CACHE].get(key);
+ if (node) {
+ const hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE])
+ return void 0;
+ } else {
+ if (doUse) {
+ if (self[UPDATE_AGE_ON_GET])
+ node.value.now = Date.now();
+ self[LRU_LIST].unshiftNode(node);
+ }
+ }
+ return hit.value;
+ }
+ };
+ var isStale = (self, hit) => {
+ if (!hit || !hit.maxAge && !self[MAX_AGE])
+ return false;
+ const diff = Date.now() - hit.now;
+ return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
+ };
+ var trim = (self) => {
+ if (self[LENGTH] > self[MAX]) {
+ for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) {
+ const prev = walker.prev;
+ del(self, walker);
+ walker = prev;
+ }
+ }
+ };
+ var del = (self, node) => {
+ if (node) {
+ const hit = node.value;
+ if (self[DISPOSE])
+ self[DISPOSE](hit.key, hit.value);
+ self[LENGTH] -= hit.length;
+ self[CACHE].delete(hit.key);
+ self[LRU_LIST].removeNode(node);
+ }
+ };
+ var Entry = class {
+ constructor(key, value, length, now, maxAge) {
+ this.key = key;
+ this.value = value;
+ this.length = length;
+ this.now = now;
+ this.maxAge = maxAge || 0;
+ }
+ };
+ var forEachStep = (self, fn, node, thisp) => {
+ let hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE])
+ hit = void 0;
+ }
+ if (hit)
+ fn.call(thisp, hit.value, hit.key, self);
+ };
+ module.exports = LRUCache;
+ }
+ });
+
+ // node_modules/semver/classes/range.js
+ var require_range = __commonJS({
+ "node_modules/semver/classes/range.js"(exports, module) {
+ var Range = class {
+ constructor(range, options) {
+ options = parseOptions(options);
+ if (range instanceof Range) {
+ if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+ return range;
+ } else {
+ return new Range(range.raw, options);
+ }
+ }
+ if (range instanceof Comparator) {
+ this.raw = range.value;
+ this.set = [[range]];
+ this.format();
+ return this;
+ }
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+ this.raw = range;
+ this.set = range.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+ if (!this.set.length) {
+ throw new TypeError(`Invalid SemVer Range: ${range}`);
+ }
+ if (this.set.length > 1) {
+ const first = this.set[0];
+ this.set = this.set.filter((c) => !isNullSet(c[0]));
+ if (this.set.length === 0) {
+ this.set = [first];
+ } else if (this.set.length > 1) {
+ for (const c of this.set) {
+ if (c.length === 1 && isAny(c[0])) {
+ this.set = [c];
+ break;
+ }
+ }
+ }
+ }
+ this.format();
+ }
+ format() {
+ this.range = this.set.map((comps) => {
+ return comps.join(" ").trim();
+ }).join("||").trim();
+ return this.range;
+ }
+ toString() {
+ return this.range;
+ }
+ parseRange(range) {
+ range = range.trim();
+ const memoOpts = Object.keys(this.options).join(",");
+ const memoKey = `parseRange:${memoOpts}:${range}`;
+ const cached = cache.get(memoKey);
+ if (cached) {
+ return cached;
+ }
+ const loose = this.options.loose;
+ const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+ debug("hyphen replace", range);
+ range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+ debug("comparator trim", range);
+ range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+ range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+ range = range.split(/\s+/).join(" ");
+ let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+ if (loose) {
+ rangeList = rangeList.filter((comp) => {
+ debug("loose invalid filter", comp, this.options);
+ return !!comp.match(re[t.COMPARATORLOOSE]);
+ });
+ }
+ debug("range list", rangeList);
+ const rangeMap = /* @__PURE__ */ new Map();
+ const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+ for (const comp of comparators) {
+ if (isNullSet(comp)) {
+ return [comp];
+ }
+ rangeMap.set(comp.value, comp);
+ }
+ if (rangeMap.size > 1 && rangeMap.has("")) {
+ rangeMap.delete("");
+ }
+ const result = [...rangeMap.values()];
+ cache.set(memoKey, result);
+ return result;
+ }
+ intersects(range, options) {
+ if (!(range instanceof Range)) {
+ throw new TypeError("a Range is required");
+ }
+ return this.set.some((thisComparators) => {
+ return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+ return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+ return rangeComparators.every((rangeComparator) => {
+ return thisComparator.intersects(rangeComparator, options);
+ });
+ });
+ });
+ });
+ }
+ test(version) {
+ if (!version) {
+ return false;
+ }
+ if (typeof version === "string") {
+ try {
+ version = new SemVer(version, this.options);
+ } catch (er) {
+ return false;
+ }
+ }
+ for (let i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version, this.options)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ };
+ module.exports = Range;
+ var LRU = require_lru_cache();
+ var cache = new LRU({ max: 1e3 });
+ var parseOptions = require_parse_options();
+ var Comparator = require_comparator();
+ var debug = require_debug();
+ var SemVer = require_semver();
+ var {
+ re,
+ t,
+ comparatorTrimReplace,
+ tildeTrimReplace,
+ caretTrimReplace
+ } = require_re();
+ var isNullSet = (c) => c.value === "<0.0.0-0";
+ var isAny = (c) => c.value === "";
+ var isSatisfiable = (comparators, options) => {
+ let result = true;
+ const remainingComparators = comparators.slice();
+ let testComparator = remainingComparators.pop();
+ while (result && remainingComparators.length) {
+ result = remainingComparators.every((otherComparator) => {
+ return testComparator.intersects(otherComparator, options);
+ });
+ testComparator = remainingComparators.pop();
+ }
+ return result;
+ };
+ var parseComparator = (comp, options) => {
+ debug("comp", comp, options);
+ comp = replaceCarets(comp, options);
+ debug("caret", comp);
+ comp = replaceTildes(comp, options);
+ debug("tildes", comp);
+ comp = replaceXRanges(comp, options);
+ debug("xrange", comp);
+ comp = replaceStars(comp, options);
+ debug("stars", comp);
+ return comp;
+ };
+ var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+ var replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c) => {
+ return replaceTilde(c, options);
+ }).join(" ");
+ var replaceTilde = (comp, options) => {
+ const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+ return comp.replace(r, (_, M, m, p, pr) => {
+ debug("tilde", comp, _, M, m, p, pr);
+ let ret;
+ if (isX(M)) {
+ ret = "";
+ } else if (isX(m)) {
+ ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+ } else if (isX(p)) {
+ ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+ } else if (pr) {
+ debug("replaceTilde pr", pr);
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+ } else {
+ ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+ }
+ debug("tilde return", ret);
+ return ret;
+ });
+ };
+ var replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c) => {
+ return replaceCaret(c, options);
+ }).join(" ");
+ var replaceCaret = (comp, options) => {
+ debug("caret", comp, options);
+ const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+ const z = options.includePrerelease ? "-0" : "";
+ return comp.replace(r, (_, M, m, p, pr) => {
+ debug("caret", comp, _, M, m, p, pr);
+ let ret;
+ if (isX(M)) {
+ ret = "";
+ } else if (isX(m)) {
+ ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+ } else if (isX(p)) {
+ if (M === "0") {
+ ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+ } else {
+ ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+ }
+ } else if (pr) {
+ debug("replaceCaret pr", pr);
+ if (M === "0") {
+ if (m === "0") {
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+ } else {
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+ }
+ } else {
+ ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+ }
+ } else {
+ debug("no pr");
+ if (M === "0") {
+ if (m === "0") {
+ ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+ } else {
+ ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+ }
+ } else {
+ ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+ }
+ }
+ debug("caret return", ret);
+ return ret;
+ });
+ };
+ var replaceXRanges = (comp, options) => {
+ debug("replaceXRanges", comp, options);
+ return comp.split(/\s+/).map((c) => {
+ return replaceXRange(c, options);
+ }).join(" ");
+ };
+ var replaceXRange = (comp, options) => {
+ comp = comp.trim();
+ const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+ return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+ debug("xRange", comp, ret, gtlt, M, m, p, pr);
+ const xM = isX(M);
+ const xm = xM || isX(m);
+ const xp = xm || isX(p);
+ const anyX = xp;
+ if (gtlt === "=" && anyX) {
+ gtlt = "";
+ }
+ pr = options.includePrerelease ? "-0" : "";
+ if (xM) {
+ if (gtlt === ">" || gtlt === "<") {
+ ret = "<0.0.0-0";
+ } else {
+ ret = "*";
+ }
+ } else if (gtlt && anyX) {
+ if (xm) {
+ m = 0;
+ }
+ p = 0;
+ if (gtlt === ">") {
+ gtlt = ">=";
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === "<=") {
+ gtlt = "<";
+ if (xm) {
+ M = +M + 1;
+ } else {
+ m = +m + 1;
+ }
+ }
+ if (gtlt === "<") {
+ pr = "-0";
+ }
+ ret = `${gtlt + M}.${m}.${p}${pr}`;
+ } else if (xm) {
+ ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+ } else if (xp) {
+ ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+ }
+ debug("xRange return", ret);
+ return ret;
+ });
+ };
+ var replaceStars = (comp, options) => {
+ debug("replaceStars", comp, options);
+ return comp.trim().replace(re[t.STAR], "");
+ };
+ var replaceGTE0 = (comp, options) => {
+ debug("replaceGTE0", comp, options);
+ return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+ };
+ var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
+ if (isX(fM)) {
+ from = "";
+ } else if (isX(fm)) {
+ from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+ } else if (isX(fp)) {
+ from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+ } else if (fpr) {
+ from = `>=${from}`;
+ } else {
+ from = `>=${from}${incPr ? "-0" : ""}`;
+ }
+ if (isX(tM)) {
+ to = "";
+ } else if (isX(tm)) {
+ to = `<${+tM + 1}.0.0-0`;
+ } else if (isX(tp)) {
+ to = `<${tM}.${+tm + 1}.0-0`;
+ } else if (tpr) {
+ to = `<=${tM}.${tm}.${tp}-${tpr}`;
+ } else if (incPr) {
+ to = `<${tM}.${tm}.${+tp + 1}-0`;
+ } else {
+ to = `<=${to}`;
+ }
+ return `${from} ${to}`.trim();
+ };
+ var testSet = (set, version, options) => {
+ for (let i = 0; i < set.length; i++) {
+ if (!set[i].test(version)) {
+ return false;
+ }
+ }
+ if (version.prerelease.length && !options.includePrerelease) {
+ for (let i = 0; i < set.length; i++) {
+ debug(set[i].semver);
+ if (set[i].semver === Comparator.ANY) {
+ continue;
+ }
+ if (set[i].semver.prerelease.length > 0) {
+ const allowed = set[i].semver;
+ if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ return true;
+ };
+ }
+ });
+
+ // node_modules/semver/classes/comparator.js
+ var require_comparator = __commonJS({
+ "node_modules/semver/classes/comparator.js"(exports, module) {
+ var ANY = Symbol("SemVer ANY");
+ var Comparator = class {
+ static get ANY() {
+ return ANY;
+ }
+ constructor(comp, options) {
+ options = parseOptions(options);
+ if (comp instanceof Comparator) {
+ if (comp.loose === !!options.loose) {
+ return comp;
+ } else {
+ comp = comp.value;
+ }
+ }
+ debug("comparator", comp, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.parse(comp);
+ if (this.semver === ANY) {
+ this.value = "";
+ } else {
+ this.value = this.operator + this.semver.version;
+ }
+ debug("comp", this);
+ }
+ parse(comp) {
+ const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+ const m = comp.match(r);
+ if (!m) {
+ throw new TypeError(`Invalid comparator: ${comp}`);
+ }
+ this.operator = m[1] !== void 0 ? m[1] : "";
+ if (this.operator === "=") {
+ this.operator = "";
+ }
+ if (!m[2]) {
+ this.semver = ANY;
+ } else {
+ this.semver = new SemVer(m[2], this.options.loose);
+ }
+ }
+ toString() {
+ return this.value;
+ }
+ test(version) {
+ debug("Comparator.test", version, this.options.loose);
+ if (this.semver === ANY || version === ANY) {
+ return true;
+ }
+ if (typeof version === "string") {
+ try {
+ version = new SemVer(version, this.options);
+ } catch (er) {
+ return false;
+ }
+ }
+ return cmp(version, this.operator, this.semver, this.options);
+ }
+ intersects(comp, options) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError("a Comparator is required");
+ }
+ if (!options || typeof options !== "object") {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ };
+ }
+ if (this.operator === "") {
+ if (this.value === "") {
+ return true;
+ }
+ return new Range(comp.value, options).test(this.value);
+ } else if (comp.operator === "") {
+ if (comp.value === "") {
+ return true;
+ }
+ return new Range(this.value, options).test(comp.semver);
+ }
+ const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
+ const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
+ const sameSemVer = this.semver.version === comp.semver.version;
+ const differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
+ const oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
+ const oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
+ return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+ }
+ };
+ module.exports = Comparator;
+ var parseOptions = require_parse_options();
+ var { re, t } = require_re();
+ var cmp = require_cmp();
+ var debug = require_debug();
+ var SemVer = require_semver();
+ var Range = require_range();
+ }
+ });
+
+ // node_modules/semver/functions/satisfies.js
+ var require_satisfies = __commonJS({
+ "node_modules/semver/functions/satisfies.js"(exports, module) {
+ var Range = require_range();
+ var satisfies = (version, range, options) => {
+ try {
+ range = new Range(range, options);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version);
+ };
+ module.exports = satisfies;
+ }
+ });
+
+ // node_modules/semver/ranges/to-comparators.js
+ var require_to_comparators = __commonJS({
+ "node_modules/semver/ranges/to-comparators.js"(exports, module) {
+ var Range = require_range();
+ var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+ module.exports = toComparators;
+ }
+ });
+
+ // node_modules/semver/ranges/max-satisfying.js
+ var require_max_satisfying = __commonJS({
+ "node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var maxSatisfying = (versions, range, options) => {
+ let max = null;
+ let maxSV = null;
+ let rangeObj = null;
+ try {
+ rangeObj = new Range(range, options);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach((v) => {
+ if (rangeObj.test(v)) {
+ if (!max || maxSV.compare(v) === -1) {
+ max = v;
+ maxSV = new SemVer(max, options);
+ }
+ }
+ });
+ return max;
+ };
+ module.exports = maxSatisfying;
+ }
+ });
+
+ // node_modules/semver/ranges/min-satisfying.js
+ var require_min_satisfying = __commonJS({
+ "node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var minSatisfying = (versions, range, options) => {
+ let min = null;
+ let minSV = null;
+ let rangeObj = null;
+ try {
+ rangeObj = new Range(range, options);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach((v) => {
+ if (rangeObj.test(v)) {
+ if (!min || minSV.compare(v) === 1) {
+ min = v;
+ minSV = new SemVer(min, options);
+ }
+ }
+ });
+ return min;
+ };
+ module.exports = minSatisfying;
+ }
+ });
+
+ // node_modules/semver/ranges/min-version.js
+ var require_min_version = __commonJS({
+ "node_modules/semver/ranges/min-version.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var gt = require_gt();
+ var minVersion = (range, loose) => {
+ range = new Range(range, loose);
+ let minver = new SemVer("0.0.0");
+ if (range.test(minver)) {
+ return minver;
+ }
+ minver = new SemVer("0.0.0-0");
+ if (range.test(minver)) {
+ return minver;
+ }
+ minver = null;
+ for (let i = 0; i < range.set.length; ++i) {
+ const comparators = range.set[i];
+ let setMin = null;
+ comparators.forEach((comparator) => {
+ const compver = new SemVer(comparator.semver.version);
+ switch (comparator.operator) {
+ case ">":
+ if (compver.prerelease.length === 0) {
+ compver.patch++;
+ } else {
+ compver.prerelease.push(0);
+ }
+ compver.raw = compver.format();
+ case "":
+ case ">=":
+ if (!setMin || gt(compver, setMin)) {
+ setMin = compver;
+ }
+ break;
+ case "<":
+ case "<=":
+ break;
+ default:
+ throw new Error(`Unexpected operation: ${comparator.operator}`);
+ }
+ });
+ if (setMin && (!minver || gt(minver, setMin))) {
+ minver = setMin;
+ }
+ }
+ if (minver && range.test(minver)) {
+ return minver;
+ }
+ return null;
+ };
+ module.exports = minVersion;
+ }
+ });
+
+ // node_modules/semver/ranges/valid.js
+ var require_valid2 = __commonJS({
+ "node_modules/semver/ranges/valid.js"(exports, module) {
+ var Range = require_range();
+ var validRange = (range, options) => {
+ try {
+ return new Range(range, options).range || "*";
+ } catch (er) {
+ return null;
+ }
+ };
+ module.exports = validRange;
+ }
+ });
+
+ // node_modules/semver/ranges/outside.js
+ var require_outside = __commonJS({
+ "node_modules/semver/ranges/outside.js"(exports, module) {
+ var SemVer = require_semver();
+ var Comparator = require_comparator();
+ var { ANY } = Comparator;
+ var Range = require_range();
+ var satisfies = require_satisfies();
+ var gt = require_gt();
+ var lt = require_lt();
+ var lte = require_lte();
+ var gte = require_gte();
+ var outside = (version, range, hilo, options) => {
+ version = new SemVer(version, options);
+ range = new Range(range, options);
+ let gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case ">":
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = ">";
+ ecomp = ">=";
+ break;
+ case "<":
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = "<";
+ ecomp = "<=";
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+ if (satisfies(version, range, options)) {
+ return false;
+ }
+ for (let i = 0; i < range.set.length; ++i) {
+ const comparators = range.set[i];
+ let high = null;
+ let low = null;
+ comparators.forEach((comparator) => {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator(">=0.0.0");
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, options)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, options)) {
+ low = comparator;
+ }
+ });
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+ if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ module.exports = outside;
+ }
+ });
+
+ // node_modules/semver/ranges/gtr.js
+ var require_gtr = __commonJS({
+ "node_modules/semver/ranges/gtr.js"(exports, module) {
+ var outside = require_outside();
+ var gtr = (version, range, options) => outside(version, range, ">", options);
+ module.exports = gtr;
+ }
+ });
+
+ // node_modules/semver/ranges/ltr.js
+ var require_ltr = __commonJS({
+ "node_modules/semver/ranges/ltr.js"(exports, module) {
+ var outside = require_outside();
+ var ltr = (version, range, options) => outside(version, range, "<", options);
+ module.exports = ltr;
+ }
+ });
+
+ // node_modules/semver/ranges/intersects.js
+ var require_intersects = __commonJS({
+ "node_modules/semver/ranges/intersects.js"(exports, module) {
+ var Range = require_range();
+ var intersects = (r1, r2, options) => {
+ r1 = new Range(r1, options);
+ r2 = new Range(r2, options);
+ return r1.intersects(r2);
+ };
+ module.exports = intersects;
+ }
+ });
+
+ // node_modules/semver/ranges/simplify.js
+ var require_simplify = __commonJS({
+ "node_modules/semver/ranges/simplify.js"(exports, module) {
+ var satisfies = require_satisfies();
+ var compare = require_compare();
+ module.exports = (versions, range, options) => {
+ const set = [];
+ let first = null;
+ let prev = null;
+ const v = versions.sort((a, b) => compare(a, b, options));
+ for (const version of v) {
+ const included = satisfies(version, range, options);
+ if (included) {
+ prev = version;
+ if (!first) {
+ first = version;
+ }
+ } else {
+ if (prev) {
+ set.push([first, prev]);
+ }
+ prev = null;
+ first = null;
+ }
+ }
+ if (first) {
+ set.push([first, null]);
+ }
+ const ranges = [];
+ for (const [min, max] of set) {
+ if (min === max) {
+ ranges.push(min);
+ } else if (!max && min === v[0]) {
+ ranges.push("*");
+ } else if (!max) {
+ ranges.push(`>=${min}`);
+ } else if (min === v[0]) {
+ ranges.push(`<=${max}`);
+ } else {
+ ranges.push(`${min} - ${max}`);
+ }
+ }
+ const simplified = ranges.join(" || ");
+ const original = typeof range.raw === "string" ? range.raw : String(range);
+ return simplified.length < original.length ? simplified : range;
+ };
+ }
+ });
+
+ // node_modules/semver/ranges/subset.js
+ var require_subset = __commonJS({
+ "node_modules/semver/ranges/subset.js"(exports, module) {
+ var Range = require_range();
+ var Comparator = require_comparator();
+ var { ANY } = Comparator;
+ var satisfies = require_satisfies();
+ var compare = require_compare();
+ var subset = (sub, dom, options = {}) => {
+ if (sub === dom) {
+ return true;
+ }
+ sub = new Range(sub, options);
+ dom = new Range(dom, options);
+ let sawNonNull = false;
+ OUTER:
+ for (const simpleSub of sub.set) {
+ for (const simpleDom of dom.set) {
+ const isSub = simpleSubset(simpleSub, simpleDom, options);
+ sawNonNull = sawNonNull || isSub !== null;
+ if (isSub) {
+ continue OUTER;
+ }
+ }
+ if (sawNonNull) {
+ return false;
+ }
+ }
+ return true;
+ };
+ var simpleSubset = (sub, dom, options) => {
+ if (sub === dom) {
+ return true;
+ }
+ if (sub.length === 1 && sub[0].semver === ANY) {
+ if (dom.length === 1 && dom[0].semver === ANY) {
+ return true;
+ } else if (options.includePrerelease) {
+ sub = [new Comparator(">=0.0.0-0")];
+ } else {
+ sub = [new Comparator(">=0.0.0")];
+ }
+ }
+ if (dom.length === 1 && dom[0].semver === ANY) {
+ if (options.includePrerelease) {
+ return true;
+ } else {
+ dom = [new Comparator(">=0.0.0")];
+ }
+ }
+ const eqSet = /* @__PURE__ */ new Set();
+ let gt, lt;
+ for (const c of sub) {
+ if (c.operator === ">" || c.operator === ">=") {
+ gt = higherGT(gt, c, options);
+ } else if (c.operator === "<" || c.operator === "<=") {
+ lt = lowerLT(lt, c, options);
+ } else {
+ eqSet.add(c.semver);
+ }
+ }
+ if (eqSet.size > 1) {
+ return null;
+ }
+ let gtltComp;
+ if (gt && lt) {
+ gtltComp = compare(gt.semver, lt.semver, options);
+ if (gtltComp > 0) {
+ return null;
+ } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+ return null;
+ }
+ }
+ for (const eq of eqSet) {
+ if (gt && !satisfies(eq, String(gt), options)) {
+ return null;
+ }
+ if (lt && !satisfies(eq, String(lt), options)) {
+ return null;
+ }
+ for (const c of dom) {
+ if (!satisfies(eq, String(c), options)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ let higher, lower;
+ let hasDomLT, hasDomGT;
+ let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+ let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+ if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+ needDomLTPre = false;
+ }
+ for (const c of dom) {
+ hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+ hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+ if (gt) {
+ if (needDomGTPre) {
+ if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+ needDomGTPre = false;
+ }
+ }
+ if (c.operator === ">" || c.operator === ">=") {
+ higher = higherGT(gt, c, options);
+ if (higher === c && higher !== gt) {
+ return false;
+ }
+ } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+ return false;
+ }
+ }
+ if (lt) {
+ if (needDomLTPre) {
+ if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+ needDomLTPre = false;
+ }
+ }
+ if (c.operator === "<" || c.operator === "<=") {
+ lower = lowerLT(lt, c, options);
+ if (lower === c && lower !== lt) {
+ return false;
+ }
+ } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+ return false;
+ }
+ }
+ if (!c.operator && (lt || gt) && gtltComp !== 0) {
+ return false;
+ }
+ }
+ if (gt && hasDomLT && !lt && gtltComp !== 0) {
+ return false;
+ }
+ if (lt && hasDomGT && !gt && gtltComp !== 0) {
+ return false;
+ }
+ if (needDomGTPre || needDomLTPre) {
+ return false;
+ }
+ return true;
+ };
+ var higherGT = (a, b, options) => {
+ if (!a) {
+ return b;
+ }
+ const comp = compare(a.semver, b.semver, options);
+ return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+ };
+ var lowerLT = (a, b, options) => {
+ if (!a) {
+ return b;
+ }
+ const comp = compare(a.semver, b.semver, options);
+ return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+ };
+ module.exports = subset;
+ }
+ });
+
+ // node_modules/semver/index.js
+ var require_semver2 = __commonJS({
+ "node_modules/semver/index.js"(exports, module) {
+ var internalRe = require_re();
+ module.exports = {
+ re: internalRe.re,
+ src: internalRe.src,
+ tokens: internalRe.t,
+ SEMVER_SPEC_VERSION: require_constants().SEMVER_SPEC_VERSION,
+ SemVer: require_semver(),
+ compareIdentifiers: require_identifiers().compareIdentifiers,
+ rcompareIdentifiers: require_identifiers().rcompareIdentifiers,
+ parse: require_parse(),
+ valid: require_valid(),
+ clean: require_clean(),
+ inc: require_inc(),
+ diff: require_diff(),
+ major: require_major(),
+ minor: require_minor(),
+ patch: require_patch(),
+ prerelease: require_prerelease(),
+ compare: require_compare(),
+ rcompare: require_rcompare(),
+ compareLoose: require_compare_loose(),
+ compareBuild: require_compare_build(),
+ sort: require_sort(),
+ rsort: require_rsort(),
+ gt: require_gt(),
+ lt: require_lt(),
+ eq: require_eq(),
+ neq: require_neq(),
+ gte: require_gte(),
+ lte: require_lte(),
+ cmp: require_cmp(),
+ coerce: require_coerce(),
+ Comparator: require_comparator(),
+ Range: require_range(),
+ satisfies: require_satisfies(),
+ toComparators: require_to_comparators(),
+ maxSatisfying: require_max_satisfying(),
+ minSatisfying: require_min_satisfying(),
+ minVersion: require_min_version(),
+ validRange: require_valid2(),
+ outside: require_outside(),
+ gtr: require_gtr(),
+ ltr: require_ltr(),
+ intersects: require_intersects(),
+ simplifyRange: require_simplify(),
+ subset: require_subset()
+ };
+ }
+ });
+
+ // dep:semver
+ var semver_default = require_semver2();
+ export {
+ semver_default as default
+ };
diff --git a/src/renderer/others/setting-schema.ts b/src/renderer/others/setting-schema.ts
new file mode 100644
index 000000000..af864211c
--- /dev/null
+++ b/src/renderer/others/setting-schema.ts
@@ -0,0 +1,526 @@
+import { cloneDeep } from 'lodash-es'
+import { DEFAULT_EXCLUDE_REGEX } from '@share/misc'
+import { isMacOS, isWindows } from '@fe/support/env'
+import { FLAG_DISABLE_XTERM, FLAG_MAS } from '@fe/support/args'
+import { SettingSchema } from '@fe/types'
+
+const schema: SettingSchema = ({
+ type: 'object',
+ title: 'T_setting-panel.setting',
+ properties: {
+ repos: {
+ defaultValue: [],
+ type: 'array',
+ title: 'T_setting-panel.schema.repos.repos',
+ format: 'table',
+ group: 'repos',
+ items: {
+ type: 'object',
+ title: 'T_setting-panel.schema.repos.repo',
+ properties: {
+ name: {
+ type: 'string',
+ title: 'T_setting-panel.schema.repos.name',
+ defaultValue: '',
+ maxLength: 10,
+ options: {
+ inputAttributes: { placeholder: 'T_setting-panel.schema.repos.name-placeholder' }
+ },
+ },
+ path: {
+ type: 'string',
+ title: 'T_setting-panel.schema.repos.path',
+ openDialogOptions: { properties: ['openDirectory', 'createDirectory'] },
+ options: {
+ inputAttributes: { placeholder: 'T_setting-panel.schema.repos.path-placeholder', style: 'cursor: pointer' }
+ },
+ },
+ enableIndexing: {
+ type: 'boolean',
+ title: 'T_setting-panel.schema.repos.enable-indexing',
+ defaultValue: false,
+ format: 'checkbox',
+ },
+ }
+ },
+ },
+ theme: {
+ defaultValue: 'system',
+ title: 'T_setting-panel.schema.theme',
+ type: 'string',
+ enum: ['system', 'dark', 'light'],
+ options: {
+ enum_titles: ['System', 'Dark', 'Light'],
+ },
+ group: 'appearance',
+ required: true,
+ },
+ language: {
+ defaultValue: 'system',
+ title: 'T_setting-panel.schema.language',
+ type: 'string',
+ enum: ['system', 'en', 'zh-CN', 'zh-TW', 'ru'],
+ options: {
+ enum_titles: ['System', 'English', '简体中文', '繁體中文', 'русский'],
+ },
+ group: 'appearance',
+ required: true,
+ },
+ 'custom-css': {
+ defaultValue: 'github.css',
+ title: 'T_setting-panel.schema.custom-css',
+ type: 'string',
+ enum: ['github.css'],
+ options: {
+ enum_titles: ['github.css'],
+ },
+ group: 'appearance',
+ required: true,
+ },
+ 'view.default-previewer-max-width': {
+ defaultValue: 1024,
+ title: 'T_setting-panel.schema.view.default-previewer-max-width',
+ type: 'number',
+ format: 'number',
+ group: 'appearance',
+ required: true,
+ description: 'T_setting-panel.schema.view.default-previewer-max-width-desc',
+ minimum: 10,
+ maximum: Number.MAX_SAFE_INTEGER,
+ },
+ 'view.default-previewer-font-family': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.view.default-previewer-font-family',
+ type: 'string',
+ group: 'appearance',
+ options: {
+ inputAttributes: { placeholder: 'e.g., \'Courier New\', monospace' }
+ },
+ },
+ 'updater.source': {
+ defaultValue: 'auto',
+ title: 'T_setting-panel.schema.updater.source',
+ type: 'string',
+ enum: ['auto', 'yank-note', 'github'],
+ group: 'other',
+ required: true,
+ },
+ 'plantuml-api': {
+ defaultValue: 'local-png',
+ title: 'T_setting-panel.schema.plantuml-api',
+ type: 'string',
+ enum: [
+ 'local-png',
+ 'local-svg',
+ 'https://www.plantuml.com/plantuml/png/{data}',
+ 'https://www.plantuml.com/plantuml/svg/{data}',
+ ],
+ options: {
+ enum_titles: [
+ 'Local (PNG) - Need Java and Graphviz',
+ 'Local (SVG) - Need Java and Graphviz',
+ 'Online (plantuml.com) - PNG',
+ 'Online (plantuml.com) - SVG',
+ ],
+ },
+ required: true,
+ group: 'other',
+ },
+ 'doc-history.number-limit': {
+ defaultValue: 500,
+ title: 'T_setting-panel.schema.doc-history.number-limit',
+ type: 'number',
+ enum: [0, 10, 20, 50, 100, 200, 500, 1000],
+ options: {
+ enum_titles: ['Disable'],
+ },
+ required: true,
+ group: 'other',
+ },
+ 'search.number-limit': {
+ defaultValue: 700,
+ title: 'T_setting-panel.schema.search.number-limit',
+ type: 'number',
+ enum: [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1300, 1600, 2000],
+ required: true,
+ group: 'other',
+ },
+ 'assets-dir': {
+ defaultValue: './FILES/{docName}',
+ title: 'T_setting-panel.schema.assets-dir',
+ type: 'string',
+ description: 'T_setting-panel.schema.assets-desc',
+ group: 'image',
+ required: true,
+ pattern: '^(?![./]+\\{docName\\})[^\\\\<>?:"|*]{1,}$',
+ options: {
+ patternmessage: '[\\<>?:"|*] are not allowed. Cannot starts with ./{docName}, /{docName} or {docName}.'
+ },
+ },
+ 'assets.path-type': {
+ defaultValue: 'auto',
+ title: 'T_setting-panel.schema.assets.path-type',
+ type: 'string',
+ group: 'image',
+ required: true,
+ enum: ['auto', 'relative', 'absolute'],
+ options: {
+ enum_titles: ['Auto', 'Relative', 'Absolute'],
+ },
+ },
+ 'editor.line-numbers': {
+ defaultValue: 'on',
+ title: 'T_setting-panel.schema.editor.line-numbers',
+ enum: ['on', 'off', 'relative', 'interval'],
+ options: {
+ enum_titles: ['On', 'Off', 'Relative', 'Interval'],
+ },
+ type: 'string',
+ group: 'editor',
+ required: true,
+ },
+ 'auto-save': {
+ defaultValue: 2000,
+ title: 'T_setting-panel.schema.auto-save',
+ enum: [0, 2000, 4000, 8000, 30000, 60000],
+ options: {
+ enum_titles: ['Disable', '2s', '4s', '8s', '30s', '60s'],
+ },
+ type: 'number',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.ordered-list-completion': {
+ defaultValue: 'increase',
+ title: 'T_setting-panel.schema.editor.ordered-list-completion',
+ type: 'string',
+ enum: ['auto', 'increase', 'one', 'off'],
+ options: {
+ enum_titles: ['Auto', '1. ···, 2. ···, 3. ···', '1. ···, 1. ···, 1. ···', 'Off'],
+ },
+ group: 'editor',
+ required: true,
+ },
+ 'editor.font-size': {
+ defaultValue: 16,
+ title: 'T_setting-panel.schema.editor.font-size',
+ type: 'number',
+ format: 'range',
+ minimum: 12,
+ maximum: 40,
+ group: 'editor',
+ },
+ 'editor.tab-size': {
+ defaultValue: 4,
+ title: 'T_setting-panel.schema.editor.tab-size',
+ type: 'number',
+ enum: [2, 4],
+ group: 'editor',
+ required: true,
+ },
+ 'editor.font-family': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.editor.font-family',
+ type: 'string',
+ group: 'editor',
+ options: {
+ inputAttributes: { placeholder: 'e.g., \'Courier New\', monospace' }
+ },
+ },
+ 'editor.font-ligatures': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.editor.font-ligatures',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.mouse-wheel-zoom': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.editor.mouse-wheel-zoom',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.minimap': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.minimap',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.enable-preview': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.enable-preview',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.quick-suggestions': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.editor.quick-suggestions',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.suggest-on-trigger-characters': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.suggest-on-trigger-characters',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.sticky-scroll-enabled': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.sticky-scroll-enabled',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.enable-trigger-suggest-bulb': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.enable-trigger-suggest-bulb',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.enable-ai-copilot-action': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.enable-ai-copilot-action',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'render.md-html': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-html',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-breaks': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-breaks',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-linkify': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-linkify',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-wiki-links': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-wiki-links',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-typographer': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.md-typographer',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-sup': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-sup',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-sub': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-sub',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.multimd-multiline': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.multimd-multiline',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ 'render.multimd-rowspan': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.multimd-rowspan',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ 'render.multimd-headerless': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.multimd-headerless',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ 'render.multimd-multibody': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.multimd-multibody',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ shell: {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.shell',
+ type: 'string',
+ group: 'other',
+ },
+ 'server.host': {
+ defaultValue: '127.0.0.1',
+ title: 'T_setting-panel.schema.server.host',
+ type: 'string',
+ enum: ['127.0.0.1', '0.0.0.0'],
+ group: 'other',
+ required: true,
+ },
+ 'server.port': {
+ defaultValue: 3044,
+ title: 'T_setting-panel.schema.server.port',
+ description: 'T_setting-panel.schema.server.port-desc',
+ type: 'integer',
+ format: 'number',
+ group: 'other',
+ required: true,
+ minimum: 10,
+ maximum: 65535,
+ },
+ 'tree.exclude': {
+ defaultValue: DEFAULT_EXCLUDE_REGEX,
+ title: 'T_setting-panel.schema.tree.exclude',
+ type: 'string',
+ group: 'other',
+ description: 'e.g., ' + DEFAULT_EXCLUDE_REGEX,
+ validator: (_schema, value, path) => {
+ if (value === '') return []
+ try {
+ // eslint-disable-next-line no-new
+ new RegExp(value)
+ return []
+ } catch (e: any) {
+ return [{ property: 'tree.exclude', path, message: e.message }]
+ }
+ }
+ },
+ 'keep-running-after-closing-window': {
+ defaultValue: !isMacOS,
+ title: 'T_setting-panel.schema.keep-running-after-closing-window',
+ type: 'boolean',
+ group: 'other',
+ format: 'checkbox',
+ required: true,
+ },
+ 'hide-main-window-on-startup': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.hide-main-window-on-startup',
+ type: 'boolean',
+ group: 'other',
+ format: 'checkbox',
+ required: true,
+ },
+ envs: {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.envs',
+ type: 'string',
+ group: 'other',
+ format: 'textarea',
+ options: {
+ inputAttributes: { placeholder: 'PATH: /opt/homebrew/bin:/use/local/bin\nGRAPHVIZ_DOT: /opt/homebrew/bin/dot', style: 'height: 4em' }
+ }
+ },
+ 'proxy.enabled': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.proxy.enabled',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'proxy',
+ },
+ 'proxy.server': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.proxy.server',
+ type: 'string',
+ group: 'proxy',
+ pattern: '^(|.+:\\d{2,5})$',
+ options: {
+ inputAttributes: { placeholder: 'e.g. 127.0.0.1:8080', }
+ }
+ },
+ 'proxy.bypass-list': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.proxy.bypass-list',
+ type: 'string',
+ group: 'proxy',
+ options: {
+ inputAttributes: { placeholder: ';*.google.com;*foo.com;1.2.3.4:5678', }
+ }
+ },
+ 'proxy.pac-url': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.proxy.pac-url',
+ type: 'string',
+ group: 'proxy',
+ options: {
+ inputAttributes: { placeholder: 'http://', }
+ }
+ },
+ } as Partial as any,
+ required: [],
+ groups: [
+ { label: 'T_setting-panel.tabs.repos', value: 'repos' },
+ { label: 'T_setting-panel.tabs.appearance', value: 'appearance' },
+ { label: 'T_setting-panel.tabs.editor', value: 'editor' },
+ { label: 'T_setting-panel.tabs.render', value: 'render' },
+ { label: 'T_setting-panel.tabs.image', value: 'image' },
+ { label: 'T_setting-panel.tabs.proxy', value: 'proxy' },
+ ]
+})
+
+if (isWindows || FLAG_DISABLE_XTERM) {
+ delete (schema.properties as any).envs
+}
+
+if (FLAG_DISABLE_XTERM) {
+ delete (schema.properties as any).shell
+ delete (schema.properties as any)['server.host']
+ delete (schema.properties as any)['server.port']
+ delete (schema.properties as any)['updater.source']
+}
+
+if (FLAG_MAS) {
+ delete (schema.properties as any)['updater.source']
+}
+
+export function getDefaultSettingSchema (): SettingSchema {
+ return cloneDeep(schema)
+}
diff --git a/src/renderer/plugins.ts b/src/renderer/plugins.ts
new file mode 100644
index 000000000..1b3b56fe7
--- /dev/null
+++ b/src/renderer/plugins.ts
@@ -0,0 +1,161 @@
+import buildInRenderers from '@fe/plugins/build-in-renderers'
+import customStyles from '@fe/plugins/custom-styles'
+import customKeybindings from '@fe/plugins/custom-keybindings'
+import electronZoom from '@fe/plugins/electron-zoom'
+import historyStack from '@fe/plugins/history-stack'
+import fileTreeFunctions from '@fe/plugins/file-tree-functions'
+import statusBarSetting from '@fe/plugins/status-bar-setting'
+import statusBarRepositorySwitch from '@fe/plugins/status-bar-repository-switch'
+import statusBarView from '@fe/plugins/status-bar-view'
+import statusBarNavigation from '@fe/plugins/status-bar-navigation'
+import statusBarInsert from '@fe/plugins/status-bar-insert'
+import statusBarTool from '@fe/plugins/status-bar-tool'
+import statusBarDocumentInfo from '@fe/plugins/status-bar-document-info'
+import statusBarHelp from '@fe/plugins/status-bar-help'
+import statusBarPremium from './plugins/status-bar-premium'
+import statusBarTheme from '@fe/plugins/status-bar-theme'
+import statusBarHistory from '@fe/plugins/status-bar-history'
+import statusBarPresentation from '@fe/plugins/status-bar-presentation'
+import controlCenter from '@fe/plugins/control-center'
+import statusBarTerminal from '@fe/plugins/status-bar-terminal'
+import statusBarExtension from '@fe/plugins/status-bar-extension'
+import statusBarGet from '@fe/plugins/status-bar-get'
+import editorPaste from '@fe/plugins/editor-paste'
+import editorAttachment from '@fe/plugins/editor-attachment'
+import editorMarkdown from '@fe/plugins/editor-markdown'
+import editorMdSyntax from '@fe/plugins/editor-md-syntax'
+import editorMdList from '@fe/plugins/editor-md-list'
+import editorWords from '@fe/plugins/editor-words'
+import editorPathCompletion from '@fe/plugins/editor-path-completion'
+import editorFolding from '@fe/plugins/editor-folding'
+import editorRestoreState from '@fe/plugins/editor-restore-state'
+import copyText from '@fe/plugins/copy-text'
+import switchTodo from '@fe/plugins/switch-todo'
+import imageViewer from '@fe/plugins/image-viewer'
+import mediaPlayer from '@fe/plugins/media-player'
+import emoji from '@fe/plugins/emoji'
+import getStarted from '@fe/plugins/get-started'
+import markdownWikiLinks from '@fe/plugins/markdown-wiki-links'
+import markdownHtml from '@fe/plugins/markdown-html'
+import markdownRenderVnode from '@fe/plugins/markdown-render-vnode'
+import markdownMacro from '@fe/plugins/markdown-macro'
+import markdownFrontMatter from '@fe/plugins/markdown-front-matter'
+import markdownImsize from '@fe/plugins/markdown-imsize'
+import markdownToc from '@fe/plugins/markdown-toc'
+import markdownCodeWrap from '@fe/plugins/markdown-code-wrap'
+import markdownCodeHighlight from '@fe/plugins/markdown-code-highlight'
+import markdownLink from '@fe/plugins/markdown-link'
+import markdownTable from '@fe/plugins/markdown-table'
+import markdownTaskList from '@fe/plugins/markdown-task-list'
+import markdownFootnote from '@fe/plugins/markdown-footnote'
+import markdownKatex from '@fe/plugins/markdown-katex'
+import markdownCodeCopy from '@fe/plugins/markdown-code-copy'
+import markdownCodeRun from '@fe/plugins/markdown-code-run'
+import markdownPlantuml from '@fe/plugins/markdown-plantuml'
+import markdownMindMap from '@fe/plugins/markdown-mind-map'
+import markdownMermaid from '@fe/plugins/markdown-mermaid'
+import markdownApplet from '@fe/plugins/markdown-applet'
+import markdownEcharts from '@fe/plugins/markdown-echarts'
+import markdownDrawio from '@fe/plugins/markdown-drawio'
+import markdownLuckysheet from '@fe/plugins/markdown-luckysheet'
+import markdownContainer from '@fe/plugins/markdown-container'
+import markdownHeadingNumber from '@fe/plugins/markdown-heading-number'
+import markdownGithubAlerts from '@fe/plugins/markdown-github-alerts'
+import markdownMisc from '@fe/plugins/misc'
+import syncScroll from '@fe/plugins/sync-scroll'
+import imageLocalization from '@fe/plugins/image-localization'
+import viewImageContextMenus from '@fe/plugins/view-image-context-menus'
+import imageHostingPicgo from '@fe/plugins/image-hosting-picgo'
+import copyContent from '@fe/plugins/copy-content'
+import sharePreview from '@fe/plugins/share-preview'
+import codeRunners from '@fe/plugins/code-runners'
+import watchFileRefresh from '@fe/plugins/watch-file-refresh'
+import previewFont from '@fe/plugins/preview-font'
+import dropToOpenFile from '@fe/plugins/drop-to-open-file'
+import recordRecentDocument from '@fe/plugins/record-recent-document'
+import aiCopilot from '@fe/plugins/ai-copilot'
+import viewLinks from '@fe/plugins/view-links'
+import insertTable from '@fe/plugins/insert-table'
+import textComparator from '@fe/plugins/text-comparator'
+
+export default [
+ buildInRenderers,
+ customStyles,
+ customKeybindings,
+ electronZoom,
+ historyStack,
+ fileTreeFunctions,
+ statusBarSetting,
+ statusBarRepositorySwitch,
+ statusBarView,
+ statusBarNavigation,
+ statusBarInsert,
+ statusBarTool,
+ statusBarDocumentInfo,
+ statusBarHelp,
+ statusBarPremium,
+ statusBarTheme,
+ statusBarHistory,
+ statusBarTerminal,
+ statusBarExtension,
+ controlCenter,
+ statusBarPresentation,
+ statusBarGet,
+ editorPaste,
+ editorAttachment,
+ editorMarkdown,
+ editorMdSyntax,
+ editorMdList,
+ editorWords,
+ editorPathCompletion,
+ editorFolding,
+ editorRestoreState,
+ copyText,
+ switchTodo,
+ imageViewer,
+ mediaPlayer,
+ emoji,
+ getStarted,
+ markdownWikiLinks,
+ markdownHtml,
+ markdownRenderVnode,
+ markdownMacro,
+ markdownFrontMatter,
+ markdownImsize,
+ markdownToc,
+ markdownCodeWrap,
+ markdownCodeHighlight,
+ markdownLink,
+ markdownTable,
+ markdownTaskList,
+ markdownFootnote,
+ markdownKatex,
+ markdownCodeCopy,
+ markdownCodeRun,
+ markdownPlantuml,
+ markdownMindMap,
+ markdownMermaid,
+ markdownApplet,
+ markdownEcharts,
+ markdownDrawio,
+ markdownLuckysheet,
+ markdownContainer,
+ markdownHeadingNumber,
+ markdownMisc,
+ syncScroll,
+ imageLocalization,
+ viewImageContextMenus,
+ imageHostingPicgo,
+ copyContent,
+ sharePreview,
+ codeRunners,
+ watchFileRefresh,
+ previewFont,
+ dropToOpenFile,
+ recordRecentDocument,
+ markdownGithubAlerts,
+ aiCopilot,
+ viewLinks,
+ insertTable,
+ textComparator,
+]
diff --git a/src/renderer/plugins/ai-copilot.ts b/src/renderer/plugins/ai-copilot.ts
new file mode 100644
index 000000000..276fd107a
--- /dev/null
+++ b/src/renderer/plugins/ai-copilot.ts
@@ -0,0 +1,47 @@
+import { Plugin } from '@fe/context'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+import type { languages } from 'monaco-editor'
+
+export default {
+ name: 'ai-copilot',
+ register: ctx => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ const extensionId = '@yank-note/extension-ai-copilot'
+ const actionId = 'install-ai-copilot-extension'
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
+
+ monaco.languages.registerCodeActionProvider('*', {
+ provideCodeActions (): languages.CodeActionList {
+ const actionTitle = ctx.i18n.t('edit-or-generate-text-using-ai')
+
+ const enabled = ctx.setting.getSetting('editor.enable-ai-copilot-action', true)
+ if (!getInitialized() || checkExtensionLoaded() || !enabled) {
+ return { dispose: () => 0, actions: [] }
+ }
+
+ const actions: languages.CodeAction[] = [{
+ title: actionTitle,
+ command: { id: actionId, title: actionTitle },
+ kind: 'refactor',
+ diagnostics: [],
+ isPreferred: true,
+ }]
+
+ return {
+ dispose: () => 0,
+ actions
+ }
+ },
+
+ async resolveCodeAction (codeAction: languages.CodeAction): Promise {
+ if (codeAction.command?.id === actionId) {
+ ctx.showExtensionManager(extensionId)
+ }
+
+ codeAction.command = undefined
+ return codeAction
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/build-in-renderers.ts b/src/renderer/plugins/build-in-renderers.ts
new file mode 100644
index 000000000..b301573eb
--- /dev/null
+++ b/src/renderer/plugins/build-in-renderers.ts
@@ -0,0 +1,79 @@
+import type { Plugin } from '@fe/context'
+import type { Doc } from '@fe/types'
+
+export default {
+ name: 'build-in-renderers',
+ register: (ctx) => {
+ ctx.renderer.registerRenderer({
+ name: 'not-markdown-file',
+ order: 999999999,
+ when (env) {
+ return !env.file || !ctx.doc.isMarkdownFile(env.file)
+ },
+ render (_, env) {
+ const { h } = ctx.lib.vue
+ return [
+ h('h1', env.file?.name),
+ h('p', [h('em', env.file ? 'Not a markdown file.' : '')])
+ ]
+ },
+ })
+
+ ctx.renderer.registerRenderer({
+ name: 'markdown',
+ order: -255,
+ when (env) {
+ return !!(env.file && ctx.doc.isMarkdownFile(env.file))
+ },
+ render (src, env) {
+ return ctx.markdown.markdown.render(src, env)
+ },
+ })
+
+ ctx.renderer.registerRenderer({
+ name: 'plain-text',
+ when (env) {
+ return !!(env.file && env.file.path.toLowerCase().endsWith('.txt'))
+ },
+ render (src) {
+ return ctx.lib.vue.h('div', {
+ style: {
+ padding: '20px',
+ whiteSpace: 'pre-wrap',
+ wordBreak: 'break-all',
+ },
+ }, src)
+ },
+ })
+
+ function isHtmlDoc (doc: Doc) {
+ return doc.type === 'file' && doc.path.toLowerCase().endsWith('.html')
+ }
+
+ let renderHtmlTime = 0
+ ctx.renderer.registerRenderer({
+ name: 'html',
+ when (env) {
+ return !!(env.file && !env.safeMode && isHtmlDoc(env.file))
+ },
+ render (src, env) {
+ const iframeProps = { style: `background: #fff; position: fixed; left: 0; top: 0; height: var(${ctx.args.CSS_VAR_NAME.PREVIEWER_HEIGHT})` }
+ const doc = env.file
+ if (doc) {
+ const url = ctx.base.getAttachmentURL(doc) + '?_t=' + renderHtmlTime
+ const html = ``
+ return ctx.lib.vue.h(ctx.embed.IFrame, { html, triggerParentKeyBoardEvent: true, iframeProps })
+ } else {
+ return ctx.lib.vue.h(ctx.embed.IFrame, { html: src, triggerParentKeyBoardEvent: true, iframeProps })
+ }
+ },
+ })
+
+ ctx.registerHook('DOC_SAVED', ({ doc }) => {
+ if (isHtmlDoc(doc)) { // render html doc after saved
+ renderHtmlTime = Date.now()
+ ctx.view.render()
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/code-runners.tsx b/src/renderer/plugins/code-runners.tsx
new file mode 100644
index 000000000..8684a1e36
--- /dev/null
+++ b/src/renderer/plugins/code-runners.tsx
@@ -0,0 +1,266 @@
+import type { Plugin } from '@fe/context'
+import { sleep } from '@fe/utils'
+import type { CodeRunnerRunOptions } from '@fe/types'
+
+const getConsole = (console: Console, resolve: (value: string) => void) => {
+ const stringify = (args: any[]) => args.map((arg) => {
+ if (['boolean', 'number', 'bigint', 'string', 'symbol', 'function'].includes(typeof arg)) {
+ return arg.toString()
+ } else {
+ return JSON.stringify(arg)
+ }
+ }).join(' ')
+
+ const tick = async (args: any[]) => {
+ const str = stringify(args) + '\n'
+ resolve(str)
+ }
+
+ return new Proxy(console, {
+ get: (obj: any, prop: any) => ['error', 'warn', 'info', 'log', 'debug'].includes(prop)
+ ? (...args: any[]) => {
+ // obj[prop](...args)
+ if (prop === 'log') {
+ tick(args)
+ } else {
+ tick([`${prop[0]}:`, ...args])
+ }
+ }
+ : obj[prop]
+ })
+}
+
+let javascriptWorker: Worker | null = null
+
+class JavascriptIframeExecutor {
+ private _code: string
+ private _signal: AbortSignal
+ private _outputType: 'plain' | 'html'
+ private _flush: CodeRunnerRunOptions['flusher']
+
+ constructor (code: string, outputHtml: boolean, opts: CodeRunnerRunOptions) {
+ this._code = code
+ this._signal = opts.signal
+ this._flush = opts.flusher
+ this._outputType = outputHtml ? 'html' : 'plain'
+ }
+
+ private _getIframe () {
+ const id = 'code-runner-javascript-vm'
+
+ // clean up
+ document.getElementById(id)?.remove()
+
+ const iframe = document.createElement('iframe')
+ iframe.id = id
+ iframe.style.display = 'none'
+ document.body.appendChild(iframe)
+
+ const iframeWindow = iframe.contentWindow! as Window & typeof globalThis
+ iframeWindow.ctx = window.ctx
+
+ return iframe
+ }
+
+ public async run () {
+ await sleep(0)
+ const iframe = this._getIframe()
+ const iframeWindow = iframe.contentWindow! as Window & typeof globalThis
+
+ const closed = new Promise(resolve => {
+ this._signal.addEventListener('abort', () => {
+ iframe.remove()
+ resolve()
+ })
+ })
+
+ const xConsole = getConsole(
+ iframeWindow.console,
+ val => this._flush(this._outputType, val),
+ )
+
+ const AsyncFunction = iframeWindow.eval('(async function(){}).constructor')
+ const fn = new AsyncFunction('console', 'ctx', this._code)
+
+ await sleep(0)
+ await fn.call(iframeWindow, xConsole, window.ctx)
+ await sleep(0)
+ this._flush(this._outputType, '')
+
+ await closed
+
+ return null
+ }
+}
+
+class JavascriptWorkerExecutor {
+ private _code: string
+ private _signal: AbortSignal
+ private _flush: CodeRunnerRunOptions['flusher']
+ private _outputType: 'plain' | 'html'
+
+ private _workerScript = `
+ const getConsole = ${getConsole.toString()}
+ self.onmessage = async (event) => {
+ const { code, isb } = event.data
+
+ const maxBuffer = 8 * 1024
+ const maxFlushInterval = 100
+
+ let buffer = ''
+
+ const flushBuffer = () => {
+ if (buffer) {
+ Atomics.wait(isb, 0, 1)
+ self.postMessage({ type: 'output', value: buffer })
+ buffer = ''
+ }
+ }
+
+ const flush = (type, val) => {
+ if (type === 'output') {
+ buffer += val
+
+ if (buffer.length > maxBuffer) {
+ flushBuffer()
+ }
+ } else {
+ flushBuffer()
+ Atomics.wait(isb, 0, 1)
+ self.postMessage({ type, value: val })
+ }
+ }
+
+ setInterval(flushBuffer, 100)
+
+ const xConsole = getConsole(console, val => flush('output', val))
+ const AsyncFunction = eval('(async function(){}).constructor')
+
+ try {
+ const fn = new AsyncFunction('console', code)
+ await fn.call(self, xConsole)
+ flush('done', '')
+ } catch (error) {
+ flush('error', error.message || String(error))
+ }
+ }
+ `
+
+ constructor (code: string, outputHtml: boolean, opts: CodeRunnerRunOptions) {
+ this._code = code
+ this._signal = opts.signal
+ this._flush = opts.flusher
+ this._outputType = outputHtml ? 'html' : 'plain'
+ }
+
+ private _getWorker () {
+ if (javascriptWorker) {
+ javascriptWorker.terminate()
+ javascriptWorker = null
+ }
+
+ const blob = new Blob([this._workerScript], { type: 'application/javascript' })
+ const url = URL.createObjectURL(blob)
+ javascriptWorker = new Worker(url)
+ URL.revokeObjectURL(url)
+
+ return javascriptWorker
+ }
+
+ public async run () {
+ await sleep(0)
+ await new Promise(resolve => {
+ const isb = new Int32Array(new SharedArrayBuffer(4))
+
+ const _flush = (value: string) => {
+ Atomics.store(isb, 0, 1)
+ Atomics.notify(isb, 0)
+ this._flush(this._outputType, value)
+ Atomics.store(isb, 0, 0)
+ Atomics.notify(isb, 0)
+ }
+
+ const worker = this._getWorker()
+ worker.onmessage = async (event) => {
+ const { type, value } = event.data
+ if (type === 'output') {
+ _flush(value)
+ } else if (type === 'error') {
+ _flush(value)
+ } else if (type === 'done') {
+ _flush('')
+ }
+ }
+
+ worker.postMessage({ code: this._code, isb })
+
+ this._signal.addEventListener('abort', () => {
+ worker.terminate()
+ resolve()
+ })
+ })
+
+ return null
+ }
+}
+
+export default {
+ name: 'code-runners',
+ register: (ctx) => {
+ ctx.runner.registerRunner({
+ name: 'javascript',
+ order: 100,
+ nonInterruptible: true,
+ match (language) {
+ return ['js', 'javascript'].includes(language.toLowerCase())
+ },
+ getTerminalCmd () {
+ return null
+ },
+ async run (_, code, opts) {
+ const firstLine = code.split('\n')[0].trim()
+ const noWorker = firstLine.includes('--no-worker--')
+ const outputHtml = firstLine.includes('--output-html--')
+ return noWorker
+ ? new JavascriptIframeExecutor(code, outputHtml, opts).run()
+ : new JavascriptWorkerExecutor(code, outputHtml, opts).run()
+ },
+ })
+
+ ctx.runner.registerRunner({
+ name: '_scripts',
+ order: 255,
+ match (language) {
+ return [
+ 'sh', 'shell',
+ 'bash', 'php',
+ 'python', 'py',
+ 'node', 'bat',
+ ].includes(language.toLowerCase())
+ },
+ getTerminalCmd () {
+ return null
+ },
+ async run () {
+ const extensionId = '@yank-note/extension-code-runner'
+ return {
+ type: 'html',
+ value: `${
+ ctx.i18n.t('install-extension-tips', 'Code Runner')
+ }`
+ }
+ },
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` Run Code (JavaScript)', insertText: '```js\n// --run--\n${1:await new Promise(r => setTimeout(r, 500))\nconsole.log("hello world!")}\n```\n', block: true },
+ { language: 'markdown', label: '/ ``` Run Code (JavaScript - No Worker)', insertText: '```js\n// --run-- --no-worker--\n${1:await new Promise(r => setTimeout(r, 500))\nctx.ui.useToast().show("info", "HELLOWORLD!")\nconsole.log("hello world!")}\n```\n', block: true },
+ { language: 'markdown', label: '/ ``` Run Code (Bash)', insertText: '```bash\n# --run--\n${1:echo HELLOWORLD}\n```\n', block: true },
+ { language: 'markdown', label: '/ ``` Run Code (C)', insertText: '```c\n// --run-- gcc \\$tmpFile.c -o \\$tmpFile.out && \\$tmpFile.out\n${1:#include \n \nint main () {\n printf("Hello, World!");\n return 0;\n}}\n```\n', block: true },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/control-center.ts b/src/renderer/plugins/control-center.ts
new file mode 100644
index 000000000..8b77a2772
--- /dev/null
+++ b/src/renderer/plugins/control-center.ts
@@ -0,0 +1,117 @@
+import { Plugin } from '@fe/context'
+import type { Components } from '@fe/types'
+
+export default {
+ name: 'status-control-center',
+ register: ctx => {
+ function buildMenuList (): Components.ControlCenter.Item[] {
+ return [
+ {
+ type: 'btn',
+ icon: 'side-bar',
+ title: ctx.i18n.t('control-center.switch.side-bar', ctx.keybinding.getKeysLabel('layout.toggle-side')),
+ checked: ctx.store.state.showSide,
+ onClick: () => {
+ ctx.layout.toggleSide()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'edit-solid',
+ title: ctx.i18n.t('control-center.switch.editor', ctx.keybinding.getKeysLabel('layout.toggle-editor')),
+ checked: ctx.store.state.showEditor,
+ onClick: () => {
+ ctx.layout.toggleEditor()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'eye-regular',
+ title: ctx.i18n.t('control-center.switch.view', ctx.keybinding.getKeysLabel('layout.toggle-view')),
+ checked: ctx.store.state.showView,
+ onClick: () => {
+ ctx.layout.toggleView()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'columns-solid',
+ title: ctx.i18n.t('control-center.switch.sync-scroll'),
+ checked: ctx.store.state.syncScroll,
+ onClick: () => {
+ ctx.view.toggleSyncScroll()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'paint-roller',
+ title: ctx.i18n.t('control-center.switch.sync-rendering'),
+ checked: ctx.store.state.autoPreview,
+ onClick: () => {
+ ctx.view.toggleAutoPreview()
+ if (ctx.store.state.autoPreview) {
+ ctx.view.refresh()
+ }
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'text-width-solid',
+ title: ctx.i18n.t('control-center.switch.word-wrap', ctx.keybinding.getKeysLabel('editor.toggle-wrap')),
+ checked: ctx.store.state.wordWrap === 'on',
+ onClick: () => {
+ ctx.editor.toggleWrap()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'keyboard-solid',
+ title: ctx.i18n.t('control-center.switch.typewriter-mode'),
+ checked: ctx.store.state.typewriterMode,
+ onClick: () => {
+ ctx.editor.toggleTypewriterMode()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'search-solid',
+ title: ctx.i18n.t('control-center.switch.find-in-preview', ctx.keybinding.getKeysLabel('view.show-find-in-preview')),
+ hidden: !ctx.store.state.showView || ctx.store.state.previewer !== 'default',
+ onClick: () => {
+ ctx.action.getActionHandler('view.show-find-in-preview')()
+ }
+ },
+ ]
+ }
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.switch.items.push(...buildMenuList())
+ })
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.navigation.items.push(
+ {
+ type: 'btn',
+ icon: 'sync-alt-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.refresh', ctx.keybinding.getKeysLabel('view.refresh')),
+ onClick: () => {
+ ctx.view.refresh()
+ ctx.workbench.ControlCenter.toggle(false)
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'bolt-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.goto', ctx.keybinding.getKeysLabel('workbench.show-quick-open')),
+ showInActionBar: true,
+ onClick: () => {
+ ctx.action.getActionHandler('workbench.show-quick-open')()
+ ctx.workbench.ControlCenter.toggle(false)
+ }
+ },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/copy-content.tsx b/src/renderer/plugins/copy-content.tsx
new file mode 100644
index 000000000..37bfc0e67
--- /dev/null
+++ b/src/renderer/plugins/copy-content.tsx
@@ -0,0 +1,194 @@
+import type { Plugin } from '@fe/context'
+import type Token from 'markdown-it/lib/token'
+
+export default {
+ name: 'copy-content',
+ register: (ctx) => {
+ const options = ctx.lib.vue.reactive({
+ type: 'rt' as 'html' | 'rt' | 'markdown',
+ inlineLocalImage: false,
+ uploadLocalImage: false,
+ inlineStyle: true,
+ highlightCode: true,
+ })
+
+ const selectionLength = ctx.lib.vue.ref(0)
+
+ const panel = ctx.lib.vue.defineComponent({
+ setup () {
+ ctx.lib.vue.watch(() => ({ ...options }), (val, prev) => {
+ if (val.uploadLocalImage && val.inlineLocalImage) {
+ if (!prev.uploadLocalImage) {
+ options.inlineLocalImage = false
+ } else {
+ options.uploadLocalImage = false
+ }
+ }
+ })
+
+ return () =>
+
+ {ctx.i18n.t('copy-content.type')}
+
+
+
+
+
+
+
+ {ctx.i18n.t('copy-content.options')}
+
+
+
+ {options.type !== 'markdown' && }
+ {options.type !== 'markdown' && }
+
+
+ {options.type !== 'markdown' &&
+ {
+ selectionLength.value
+ ? ctx.i18n.t('copy-content.copy-tips-selected', String(selectionLength.value))
+ : ctx.i18n.t('copy-content.copy-tips')
+ }
+ }
+
+ }
+ })
+
+ async function transformMarkdown () {
+ let markdown = ctx.store.state.currentContent
+ const tokens = ctx.view.getRenderEnv()?.tokens
+ if (!markdown || !tokens) {
+ return
+ }
+
+ const processImg = async (tokens: Token[]) => {
+ for (const token of tokens) {
+ if (token.children) {
+ await processImg(token.children)
+ }
+
+ if (token.tag === 'img' && token.attrGet(ctx.args.DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ const srcAttr = token.attrGet('src')
+ const originSrc = token.attrGet(ctx.args.DOM_ATTR_NAME.ORIGIN_SRC)
+ if (srcAttr && originSrc) {
+ const res: Response = await ctx.api.fetchHttp(srcAttr)
+ const fileName = ctx.utils.path.basename(ctx.utils.removeQuery(originSrc))
+ const file = new File(
+ [await res.blob()],
+ fileName,
+ { type: ctx.lib.mime.getType(fileName) || undefined }
+ )
+
+ let url: string | undefined
+ if (options.inlineLocalImage) {
+ url = await ctx.utils.fileToBase64URL(file)
+ } else if (options.uploadLocalImage) {
+ url = await ctx.action.getActionHandler('plugin.image-hosting-picgo.upload')(file)
+ }
+
+ if (url) {
+ markdown = markdown.replaceAll(
+ ctx.utils.encodeMarkdownLink(originSrc),
+ ctx.utils.encodeMarkdownLink(url)
+ )
+ }
+ }
+ }
+ }
+ }
+
+ await processImg(tokens)
+
+ return markdown
+ }
+
+ async function copyContent () {
+ const iframe = await ctx.view.getRenderIframe()
+ selectionLength.value = iframe.contentWindow?.getSelection()?.toString()?.trim()?.length || 0
+
+ if (await ctx.ui.useModal().confirm({
+ title: ctx.i18n.t('status-bar.tool.copy-content'),
+ component: panel,
+ })) {
+ try {
+ const startedAt = Date.now()
+ ctx.ui.useToast().show('info', ctx.i18n.t('loading'), 10000)
+ const content = options.type === 'markdown'
+ ? await transformMarkdown()
+ : await ctx.view.getContentHtml({ ...options, onlySelected: selectionLength.value > 0 })
+
+ if (Date.now() - startedAt > 3000) {
+ await ctx.ui.useModal().alert({ content: ctx.i18n.t('copy-content.complete') })
+ }
+
+ if (options.type === 'rt') {
+ await ctx.base.writeToClipboard('text/html', content)
+ ctx.ui.useToast().show('info', ctx.i18n.t('copied'))
+ } else {
+ ctx.utils.copyText(content)
+ }
+ } catch (error: any) {
+ console.error(error)
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ }
+
+ const id = 'plugin.copy-content.copy-content'
+
+ ctx.action.registerAction({
+ name: id,
+ description: ctx.i18n.t('command-desc.plugin_copy-content_copy-content'),
+ handler: copyContent,
+ forUser: true,
+ keys: [ctx.keybinding.CtrlCmd, ctx.keybinding.Shift, 'c'],
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-tool']?.list?.push(
+ {
+ id,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.tool.copy-content'),
+ subTitle: ctx.keybinding.getKeysLabel(id),
+ onClick: () => copyContent(),
+ ellipsis: true,
+ order: 100,
+ },
+ )
+ })
+
+ ctx.theme.addStyles(`
+ .copy-content {
+ margin-top: 20px;
+ }
+
+ .copy-content > div {
+ padding: 4px 12px;
+ display: flex;
+ }
+
+ .copy-content > div > div {
+ display: flex;
+ flex-wrap: wrap;
+ }
+
+ .copy-content .label {
+ width: 100px;
+ flex: none;
+ }
+
+ .copy-content label {
+ margin-left: 12px;
+ white-space: nowrap;
+ margin-bottom: 8px;
+ }
+
+ .copy-content .copy-content-tips {
+ font-size: 13px;
+ color: var(--g-color-35);
+ }
+ `)
+ }
+} as Plugin
diff --git a/src/renderer/plugins/copy-text.ts b/src/renderer/plugins/copy-text.ts
index dc5cb10c6..75996883e 100644
--- a/src/renderer/plugins/copy-text.ts
+++ b/src/renderer/plugins/copy-text.ts
@@ -1,15 +1,12 @@
-import { Plugin, Ctx } from '@fe/context/plugin'
-import { hasCtrlCmd } from '@fe/context/shortcut'
-import { encodeMarkdownLink } from '@fe/utils'
-import { copyText } from '@fe/support/copy-text'
+import { Plugin } from '@fe/context'
+import { hasCtrlCmd } from '@fe/core/keybinding'
+import { copyText, encodeMarkdownLink } from '@fe/utils'
import store from '@fe/support/store'
export default {
name: 'copy-text',
- register: (ctx: Ctx) => {
- ctx.action.registerAction('app.copy-text', copyText)
-
- ctx.registerHook('ON_VIEW_ELEMENT_CLICK', async (e: MouseEvent) => {
+ register: (ctx) => {
+ ctx.registerHook('VIEW_ELEMENT_CLICK', async ({ e }) => {
const target = e.target as HTMLElement
const preventEvent = () => {
@@ -18,16 +15,26 @@ export default {
return true
}
- // 复制标题链接
+ // copy heading link.
if (['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].indexOf(target.tagName) > -1 && target.id && hasCtrlCmd(e)) {
const { currentFile } = store.state
if (currentFile) {
- copyText(encodeMarkdownLink(currentFile.path) + '#' + encodeMarkdownLink(decodeURIComponent(target.id)))
+ let path = currentFile.path
+ if (!path.startsWith('/')) {
+ path = '/' + path
+ }
+
+ copyText(encodeMarkdownLink(path) + '#' + encodeMarkdownLink(decodeURIComponent(target.id)))
return preventEvent()
}
}
- // 复制内容
+ if (target.classList.contains('copy-text') && target.dataset.text) {
+ copyText(target.dataset.text)
+ return preventEvent()
+ }
+
+ // copy content.
if (target.classList.contains('copy-inner-text') && hasCtrlCmd(e)) {
copyText(target.innerText)
return preventEvent()
diff --git a/src/renderer/plugins/custom-keybindings.ts b/src/renderer/plugins/custom-keybindings.ts
new file mode 100644
index 000000000..d83e46be4
--- /dev/null
+++ b/src/renderer/plugins/custom-keybindings.ts
@@ -0,0 +1,279 @@
+/* eslint-disable quote-props */
+import type { Plugin } from '@fe/context'
+import type * as Monaco from 'monaco-editor'
+import { getLogger } from '@fe/utils'
+import { isMacOS } from '@fe/support/env'
+
+const logger = getLogger('plugin:custom-keybindings')
+
+let cachedMap: Record
+
+function getCode (monaco: typeof Monaco, key: string): number {
+ if (!cachedMap) {
+ cachedMap = {
+ 'ctrl': isMacOS ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd,
+ 'control': isMacOS ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd,
+ 'shift': monaco.KeyMod.Shift,
+ 'alt': monaco.KeyMod.Alt,
+ 'meta': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'cmd': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'command': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'win': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'backspace': monaco.KeyCode.Backspace,
+ 'tab': monaco.KeyCode.Tab,
+ 'enter': monaco.KeyCode.Enter,
+ 'pause': monaco.KeyCode.PauseBreak,
+ 'capslock': monaco.KeyCode.CapsLock,
+ 'esc': monaco.KeyCode.Escape,
+ 'space': monaco.KeyCode.Space,
+ 'pageup': monaco.KeyCode.PageUp,
+ 'pagedown': monaco.KeyCode.PageDown,
+ 'end': monaco.KeyCode.End,
+ 'home': monaco.KeyCode.Home,
+ 'left': monaco.KeyCode.LeftArrow,
+ 'up': monaco.KeyCode.UpArrow,
+ 'right': monaco.KeyCode.RightArrow,
+ 'down': monaco.KeyCode.DownArrow,
+ 'arrowleft': monaco.KeyCode.LeftArrow,
+ 'arrowup': monaco.KeyCode.UpArrow,
+ 'arrowright': monaco.KeyCode.RightArrow,
+ 'arrowdown': monaco.KeyCode.DownArrow,
+ 'insert': monaco.KeyCode.Insert,
+ 'delete': monaco.KeyCode.Delete,
+ '0': monaco.KeyCode.Digit0,
+ '1': monaco.KeyCode.Digit1,
+ '2': monaco.KeyCode.Digit2,
+ '3': monaco.KeyCode.Digit3,
+ '4': monaco.KeyCode.Digit4,
+ '5': monaco.KeyCode.Digit5,
+ '6': monaco.KeyCode.Digit6,
+ '7': monaco.KeyCode.Digit7,
+ '8': monaco.KeyCode.Digit8,
+ '9': monaco.KeyCode.Digit9,
+ 'a': monaco.KeyCode.KeyA,
+ 'b': monaco.KeyCode.KeyB,
+ 'c': monaco.KeyCode.KeyC,
+ 'd': monaco.KeyCode.KeyD,
+ 'e': monaco.KeyCode.KeyE,
+ 'f': monaco.KeyCode.KeyF,
+ 'g': monaco.KeyCode.KeyG,
+ 'h': monaco.KeyCode.KeyH,
+ 'i': monaco.KeyCode.KeyI,
+ 'j': monaco.KeyCode.KeyJ,
+ 'k': monaco.KeyCode.KeyK,
+ 'l': monaco.KeyCode.KeyL,
+ 'm': monaco.KeyCode.KeyM,
+ 'n': monaco.KeyCode.KeyN,
+ 'o': monaco.KeyCode.KeyO,
+ 'p': monaco.KeyCode.KeyP,
+ 'q': monaco.KeyCode.KeyQ,
+ 'r': monaco.KeyCode.KeyR,
+ 's': monaco.KeyCode.KeyS,
+ 't': monaco.KeyCode.KeyT,
+ 'u': monaco.KeyCode.KeyU,
+ 'v': monaco.KeyCode.KeyV,
+ 'w': monaco.KeyCode.KeyW,
+ 'x': monaco.KeyCode.KeyX,
+ 'y': monaco.KeyCode.KeyY,
+ 'z': monaco.KeyCode.KeyZ,
+ 'contextmenu': monaco.KeyCode.ContextMenu,
+ 'f1': monaco.KeyCode.F1,
+ 'f2': monaco.KeyCode.F2,
+ 'f3': monaco.KeyCode.F3,
+ 'f4': monaco.KeyCode.F4,
+ 'f5': monaco.KeyCode.F5,
+ 'f6': monaco.KeyCode.F6,
+ 'f7': monaco.KeyCode.F7,
+ 'f8': monaco.KeyCode.F8,
+ 'f9': monaco.KeyCode.F9,
+ 'f10': monaco.KeyCode.F10,
+ 'f11': monaco.KeyCode.F11,
+ 'f12': monaco.KeyCode.F12,
+ 'f13': monaco.KeyCode.F13,
+ 'f14': monaco.KeyCode.F14,
+ 'f15': monaco.KeyCode.F15,
+ 'f16': monaco.KeyCode.F16,
+ 'f17': monaco.KeyCode.F17,
+ 'f18': monaco.KeyCode.F18,
+ 'f19': monaco.KeyCode.F19,
+ 'f20': monaco.KeyCode.F20,
+ 'f21': monaco.KeyCode.F21,
+ 'f22': monaco.KeyCode.F22,
+ 'f23': monaco.KeyCode.F23,
+ 'f24': monaco.KeyCode.F24,
+ 'numlock': monaco.KeyCode.NumLock,
+ 'scrolllock': monaco.KeyCode.ScrollLock,
+ ';': monaco.KeyCode.Semicolon,
+ '=': monaco.KeyCode.Equal,
+ ',': monaco.KeyCode.Comma,
+ '-': monaco.KeyCode.Minus,
+ '.': monaco.KeyCode.Period,
+ '/': monaco.KeyCode.Slash,
+ '`': monaco.KeyCode.Backquote,
+ '[': monaco.KeyCode.BracketLeft,
+ '\\': monaco.KeyCode.Backslash,
+ ']': monaco.KeyCode.BracketRight,
+ '\'': monaco.KeyCode.Quote,
+ 'oem_8': monaco.KeyCode.OEM_8,
+ 'intlbackslash': monaco.KeyCode.IntlBackslash,
+ 'numpad0': monaco.KeyCode.Numpad0,
+ 'numpad1': monaco.KeyCode.Numpad1,
+ 'numpad2': monaco.KeyCode.Numpad2,
+ 'numpad3': monaco.KeyCode.Numpad3,
+ 'numpad4': monaco.KeyCode.Numpad4,
+ 'numpad5': monaco.KeyCode.Numpad5,
+ 'numpad6': monaco.KeyCode.Numpad6,
+ 'numpad7': monaco.KeyCode.Numpad7,
+ 'numpad8': monaco.KeyCode.Numpad8,
+ 'numpad9': monaco.KeyCode.Numpad9,
+ 'numpadmultiply': monaco.KeyCode.NumpadMultiply,
+ 'numpadadd': monaco.KeyCode.NumpadAdd,
+ 'numpadsubtract': monaco.KeyCode.NumpadSubtract,
+ 'numpaddecimal': monaco.KeyCode.NumpadDecimal,
+ 'numpaddivide': monaco.KeyCode.NumpadDivide,
+ }
+ }
+
+ return cachedMap[key.trim().toLowerCase()]
+}
+
+function resolveKeys (monaco: typeof Monaco, keys: string | null): number {
+ if (!keys) {
+ return 0
+ }
+
+ let result = 0
+ const keyNames = keys.split('+')
+
+ for (const keyName of keyNames) {
+ const code = getCode(monaco, keyName)
+ if (!code) {
+ return 0
+ }
+
+ if (result) {
+ result |= code
+ } else {
+ result = code
+ }
+ }
+
+ return result
+}
+
+type Chord = {
+ altKey: boolean
+ ctrlKey: boolean
+ keyCode: number
+ metaKey: boolean
+ shiftKey: boolean
+}
+
+function encodeMonacoChord (monaco: typeof Monaco, chord: Chord): number {
+ const { altKey, ctrlKey, keyCode, metaKey, shiftKey } = chord
+ let result = 0
+
+ altKey && (result |= monaco.KeyMod.Alt)
+ ctrlKey && (result |= (isMacOS ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd))
+ metaKey && (result |= (isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl))
+ shiftKey && (result |= monaco.KeyMod.Shift)
+
+ return result | keyCode
+}
+
+function encodeMonacoChords (monaco: typeof Monaco, chords: Chord[]): number {
+ if (!chords.length) {
+ return 0
+ }
+
+ const [first, second] = chords
+
+ if (!second) {
+ return encodeMonacoChord(monaco, first)
+ }
+
+ return monaco.KeyMod.chord(
+ encodeMonacoChord(monaco, first),
+ encodeMonacoChord(monaco, second)
+ )
+}
+
+export default {
+ name: 'custom-keybindings',
+ register: (ctx) => {
+ let disposable: Monaco.IDisposable | null = null
+
+ function updateEditorKeybindings () {
+ try {
+ const monaco = ctx.editor.getMonaco()
+ const editor = ctx.editor.getEditor()
+ const service = (editor as any)._standaloneKeybindingService
+
+ disposable?.dispose()
+ disposable = null
+
+ const keybindings = ctx.setting.getSetting('keybindings', []).filter(x => x.type === 'editor')
+ const newKeybindings: Parameters[0] = []
+
+ for (const keybinding of keybindings) {
+ // get original keybinding, for get when condition
+ const originalKeybinding = service._getResolver().lookupPrimaryKeybinding(keybinding.command, service._contextKeyService)
+ let when: string | undefined
+ if (originalKeybinding) {
+ // get when condition expression
+ when = originalKeybinding.when?.serialize()
+ const originMonacoKeys = encodeMonacoChords(monaco, originalKeybinding.resolvedKeybinding._chords)
+ // remove original keybinding
+ newKeybindings.push({ keybinding: originMonacoKeys, command: `-${keybinding.command}`, when })
+ }
+
+ const monacoKeys = resolveKeys(monaco, keybinding.keys)
+
+ if (!monacoKeys && keybinding.keys) {
+ logger.warn('updateEditorKeybindings', `invalid keybinding ${keybinding.keys} for command ${keybinding.command}`)
+ }
+
+ if (monacoKeys) {
+ // new keybinding
+ newKeybindings.push({ keybinding: monacoKeys, command: keybinding.command, when })
+ }
+ }
+
+ logger.debug('updateEditorKeybindings', newKeybindings)
+
+ if (newKeybindings.length) {
+ disposable = monaco.editor.addKeybindingRules(newKeybindings)
+ }
+ } catch (error) {
+ console.error(error)
+ ctx.ui.useToast().show('warning', 'Failed to update editor keybindings')
+ }
+ }
+
+ ctx.action.tapAction(action => {
+ const keybindings = ctx.lib.lodash.keyBy(
+ ctx.setting.getSetting('keybindings', []).filter(x => x.type === 'workbench'),
+ 'command'
+ )
+
+ if (keybindings[action.name]) {
+ action.keys = keybindings[action.name].keys?.split('+') || []
+ }
+ })
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys }) => {
+ if (changedKeys.includes('keybindings')) {
+ ctx.triggerHook('COMMAND_KEYBINDING_CHANGED')
+ updateEditorKeybindings()
+ }
+ })
+
+ ctx.editor.whenEditorReady().then(() => {
+ updateEditorKeybindings()
+
+ // recheck keybindings, for conflict with other keybindings
+ setTimeout(updateEditorKeybindings, 2000)
+ setTimeout(updateEditorKeybindings, 5000)
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/custom-styles.ts b/src/renderer/plugins/custom-styles.ts
new file mode 100644
index 000000000..fa2b031a5
--- /dev/null
+++ b/src/renderer/plugins/custom-styles.ts
@@ -0,0 +1,52 @@
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'custom-styles',
+ register: (ctx) => {
+ ctx.registerHook('STARTUP', () => {
+ const head = document.getElementsByTagName('head')[0]
+ const cssLink = document.createElement('link')
+ cssLink.id = 'custom-css'
+ cssLink.rel = 'stylesheet'
+ cssLink.type = 'text/css'
+ cssLink.href = ctx.args.FLAG_DEMO ? '/github.css' : '/custom-css'
+
+ head.appendChild(cssLink)
+
+ // for demo
+ if (ctx.args.FLAG_DEMO) {
+ ctx.view.addStyleLink('/github.css')
+ }
+ })
+
+ if (ctx.args.FLAG_DEMO) {
+ return
+ }
+
+ ctx.registerHook('SETTING_PANEL_BEFORE_SHOW', async () => {
+ const customStyles = await ctx.api.fetchCustomStyles().catch(() => [])
+ ctx.theme.removeThemeStyle(item => item.from === 'custom')
+ customStyles.forEach(css => {
+ ctx.theme.registerThemeStyle({ from: 'custom', name: css, css })
+ })
+
+ const styles = ctx.theme.getThemeStyles()
+
+ ctx.setting.changeSchema((schema) => {
+ schema.properties['custom-css'].enum = styles.map(x => x.css)
+ schema.properties['custom-css'].options.enum_titles = styles.map(x => x.name)
+ })
+ })
+
+ ctx.registerHook('SETTING_CHANGED', async ({ changedKeys }) => {
+ if (changedKeys.includes('custom-css')) {
+ if (await ctx.ui.useModal().confirm({
+ title: ctx.i18n.t('custom-css.change-confirm.title'),
+ content: ctx.i18n.t('custom-css.change-confirm.content')
+ })) {
+ ctx.base.reloadMainWindow()
+ }
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/drop-to-open-file.ts b/src/renderer/plugins/drop-to-open-file.ts
new file mode 100644
index 000000000..054c73f4d
--- /dev/null
+++ b/src/renderer/plugins/drop-to-open-file.ts
@@ -0,0 +1,89 @@
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'drop-to-open-file',
+ register: (ctx) => {
+ // only support electron
+ if (!ctx.env.isElectron) {
+ return
+ }
+
+ const dragClassName = 'drop-file-dragover-mask'
+ const rightSelector = 'body > #app > .layout .main > .right'
+ let isDrag = true
+
+ function getRightDom () {
+ return document.body.querySelector(rightSelector)
+ }
+
+ function isDragFile (e: DragEvent): boolean {
+ const hasFile = !!e.dataTransfer?.items &&
+ e.dataTransfer.items.length > 0 &&
+ e.dataTransfer.items[0].kind === 'file'
+
+ // only handle drag to right section
+ return hasFile && (e.target as HTMLElement).closest(rightSelector) === getRightDom()
+ }
+
+ function enableDropStyle (e: DragEvent) {
+ if (isDragFile(e)) {
+ isDrag = true
+ e.stopPropagation()
+ e.preventDefault()
+ getRightDom()?.classList.add(dragClassName)
+ }
+ }
+
+ function onDrop (e: DragEvent) {
+ disableDropStyle()
+
+ if (isDragFile(e)) {
+ const item = e.dataTransfer?.items?.[0]
+ // if drag image file, do nothing. let editor handle it
+ if (item && !item.type.toLowerCase().startsWith('image')) {
+ const path = item?.getAsFile()?.path
+ if (path) {
+ e.stopPropagation()
+ e.preventDefault()
+ ctx.doc.switchDocByPath(path)
+ }
+ }
+ }
+ }
+
+ async function disableDropStyle () {
+ isDrag = false
+ await ctx.utils.sleep(50)
+ if (!isDrag) {
+ getRightDom()?.classList.remove(dragClassName)
+ }
+ }
+
+ function listenEvent (win: Window) {
+ win.addEventListener('dragover', enableDropStyle, true)
+ win.addEventListener('dragenter', enableDropStyle, true)
+ win.addEventListener('dragend', disableDropStyle, true)
+ win.addEventListener('dragleave', disableDropStyle, true)
+ win.addEventListener('drop', onDrop, true)
+ }
+
+ listenEvent(window)
+ ctx.view.getRenderIframe().then((iframe) => {
+ listenEvent(iframe.contentWindow!)
+ })
+
+ ctx.theme.addStyles(`
+ .${dragClassName}::after {
+ content: '';
+ position: absolute;
+ pointer-events: none;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background: rgba(0, 0, 0, 0.2);
+ z-index: 210000000;
+ }
+ `)
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-attachment.ts b/src/renderer/plugins/editor-attachment.ts
index bcc2a1c5f..d9cecb66f 100644
--- a/src/renderer/plugins/editor-attachment.ts
+++ b/src/renderer/plugins/editor-attachment.ts
@@ -1,43 +1,67 @@
import dayjs from 'dayjs'
-import { insert, whenEditorReady } from '@fe/context/editor'
-import type { Plugin } from '@fe/context/plugin'
-import * as api from '@fe/support/api'
+import { insert, whenEditorReady } from '@fe/services/editor'
+import type { Plugin } from '@fe/context'
+import type { Doc } from '@fe/types'
+import { encodeMarkdownLink, escapeMd } from '@fe/utils'
+import { basename, dirname, isBelongTo, join, normalizeSep, relative } from '@fe/utils/path'
import store from '@fe/support/store'
-import { encodeMarkdownLink } from '@fe/utils'
-import { Doc } from '@fe/support/types'
-import { dirname, isBelongTo, join, relative } from '@fe/utils/path'
-import { getAction } from '@fe/context/action'
+import * as api from '@fe/support/api'
+import { refreshTree } from '@fe/services/tree'
+import { upload } from '@fe/services/base'
+import { isSameRepo } from '@fe/services/document'
+import { useToast } from '@fe/support/ui/toast'
+import { DOM_CLASS_NAME } from '@fe/support/args'
+import { t } from '@fe/services/i18n'
async function uploadFile (file: any, asImage: boolean) {
if (!store.state.currentFile) {
- throw new Error('当前未打开文件')
+ throw new Error('No file opened.')
}
- const { repo, path } = store.state.currentFile
- const filename = asImage ? null : `${dayjs().format('YYYYMMDDHHmmss')}.${file.name}`
- const { relativePath } = await api.upload(repo, path, file, filename)
+ const filename = file.name
+ const assetPath = await upload(file, store.state.currentFile, filename)
if (asImage) {
- insert(`})`)
+ insert(`})\n`)
} else {
- insert(`附件 [${dayjs().format('YYYY-MM-DD HH:mm')}] [${file.name} (${(file.size / 1024).toFixed(2)}KiB)](${encodeMarkdownLink(relativePath)}){class=open target=_blank}\n`)
+ insert(`[${dayjs().format('YYYY-MM-DD HH:mm')}] [${escapeMd(file.name)} (${(file.size / 1024).toFixed(2)}KiB)](${encodeMarkdownLink(assetPath)}){.${DOM_CLASS_NAME.MARK_OPEN}}\n`)
}
+
+ refreshTree()
}
function addAttachment (asImage = false) {
const input = window.document.createElement('input')
input.type = 'file'
- input.onchange = () => {
+ input.multiple = true
+ input.onchange = async () => {
for (let i = 0; i < input.files!.length; i++) {
- uploadFile(input.files![i], asImage)
+ await uploadFile(input.files![i], asImage)
}
}
input.click()
}
-function addDocument (doc: Doc) {
+async function linkFile () {
+ const { filePaths } = await api.choosePath({ properties: ['openFile', 'multiSelections'] })
+ const useList = filePaths.length > 1
+ for (let path of filePaths) {
+ path = normalizeSep(path)
+ const filename = basename(path)
+ insert(`${useList ? '- ' : ''}[${escapeMd(filename)}](file://${encodeMarkdownLink(path)})\n`)
+ }
+}
+
+function addDocument (doc?: Doc | null) {
+ if (!doc) return
+
const file = store.state.currentFile
if (file) {
+ if (!isSameRepo(file, doc)) {
+ useToast().show('warning', t('insert-different-repo-doc'))
+ return
+ }
+
const cwd = dirname(file.path)
const filePath = isBelongTo(cwd, doc.path)
? relative(cwd, doc.path)
@@ -45,43 +69,93 @@ function addDocument (doc: Doc) {
const fileName = doc.name.replace(/\.[^.]*$/, '')
insert(`[${fileName}](${encodeMarkdownLink(filePath)})`)
} else {
- throw new Error('当前未打开文件')
+ throw new Error('No file opened.')
}
}
export default {
name: 'editor-attachment',
- register: () => {
+ register: (ctx) => {
+ const idAddImage = 'plugin.editor.add-image'
+ const idAddFile = 'plugin.editor.add-file'
+ const idLinkDoc = 'plugin.editor.link-doc'
+ const idLinkFile = 'plugin.editor.link-file'
+
whenEditorReady().then(({ editor, monaco }) => {
editor.addAction({
- id: 'plugin.editor.add-image',
+ id: idAddImage,
contextMenuGroupId: 'modification',
- label: '上传图片',
+ label: t('add-image'),
keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_I
+ monaco.KeyMod.Alt | monaco.KeyCode.KeyI
],
run: () => addAttachment(true),
})
editor.addAction({
- id: 'plugin.editor.add-file',
+ id: idAddFile,
contextMenuGroupId: 'modification',
- label: '插入附件',
+ label: t('editor.context-menu.add-attachment'),
keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_F
+ monaco.KeyMod.Alt | monaco.KeyCode.KeyF
],
run: () => addAttachment(false),
})
editor.addAction({
- id: 'plugin.editor.add-document',
+ id: idLinkDoc,
contextMenuGroupId: 'modification',
- label: '插入文档',
+ label: t('editor.context-menu.link-doc'),
keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_I
+ monaco.KeyMod.Alt | monaco.KeyCode.KeyD
],
- run: () => {
- getAction('filter.choose-document')().then(addDocument)
- },
+ run: () => ctx.routines.chooseDocument().then(addDocument),
})
+ editor.addAction({
+ id: idLinkFile,
+ contextMenuGroupId: 'modification',
+ label: t('editor.context-menu.link-file'),
+ keybindings: [
+ monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.KeyF
+ ],
+ run: () => linkFile(),
+ })
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push(
+ {
+ id: idAddImage,
+ type: 'normal',
+ title: ctx.i18n.t('add-image'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idAddImage) || []),
+ ellipsis: true,
+ onClick: () => addAttachment(true),
+ },
+ {
+ id: idAddFile,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.add-attachment'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idAddFile) || []),
+ ellipsis: true,
+ onClick: () => addAttachment(false),
+ },
+ {
+ id: idLinkDoc,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.link-doc'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idLinkDoc) || []),
+ ellipsis: true,
+ onClick: () => ctx.routines.chooseDocument().then(addDocument),
+ },
+ {
+ id: idLinkFile,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.link-file'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idLinkFile) || []),
+ ellipsis: true,
+ onClick: () => linkFile(),
+ },
+ { type: 'separator' },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/editor-folding.ts b/src/renderer/plugins/editor-folding.ts
new file mode 100644
index 000000000..94b048501
--- /dev/null
+++ b/src/renderer/plugins/editor-folding.ts
@@ -0,0 +1,168 @@
+import type * as Monaco from 'monaco-editor'
+import { IndentRangeProvider } from '@fe/others/monaco-indent-range-provider.js'
+import type { Ctx, Plugin } from '@fe/context'
+import type Token from 'markdown-it/lib/token'
+import { DOM_ATTR_NAME } from '@fe/support/args'
+
+const lengthLimit = 50000
+const rangeLimit = 5000
+
+type TocEntry = {
+ level: number,
+ start: number,
+ end: number,
+}
+
+export class MdFoldingProvider implements Monaco.languages.FoldingRangeProvider {
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ public async provideFoldingRanges (model: Monaco.editor.ITextModel, _context: Monaco.languages.FoldingContext, cancellationToken: Monaco.CancellationToken, retry = true): Promise {
+ if (model.uri.toString() !== this.ctx.doc.toUri(this.ctx.view.getRenderEnv()?.file)) {
+ if (retry) {
+ await this.ctx.utils.sleep(1000)
+ return await this.provideFoldingRanges(model, _context, cancellationToken, false)
+ }
+
+ return []
+ }
+
+ if (model.getValueLength() > lengthLimit) {
+ return []
+ }
+
+ const foldables = await Promise.all([
+ this.getHeaderFoldingRanges(model),
+ this.getBlockFoldingRanges(model),
+ new IndentRangeProvider(model).compute(cancellationToken).then((ranges: any) => {
+ const length = ranges.length
+ const result: Monaco.languages.FoldingRange[] = []
+ for (let i = 0; i < length; i++) {
+ result.push({
+ start: ranges.getStartLineNumber(i),
+ end: ranges.getEndLineNumber(i),
+ })
+ }
+
+ return result
+ })
+ ])
+ return foldables.flat().slice(0, rangeLimit)
+ }
+
+ private async getHeaderFoldingRanges (model: Monaco.editor.ITextModel): Promise {
+ return (await this.buildToc(model)).map(entry => {
+ let { start, end } = entry
+ start++
+ end++
+ return { start, end }
+ })
+ }
+
+ private getRealLine (token: Token) {
+ if (token.meta.attrs && token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_START] && token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_END]) {
+ return [
+ parseInt(token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_START]) - 1,
+ parseInt(token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_END]) - 1,
+ ]
+ }
+
+ return token.map!
+ }
+
+ private async getBlockFoldingRanges (model: Monaco.editor.ITextModel): Promise {
+ const tokens = this.ctx.view.getRenderEnv()?.tokens || []
+ const multiLineListItems = tokens.filter(this.isFoldableToken.bind(this))
+ return multiLineListItems.map(listItem => {
+ const [startLine, endLine] = this.getRealLine(listItem)
+ const start = startLine + 1
+ let end = endLine
+ if (model.getLineContent(end).trim().length === 0 && end >= start + 1) {
+ end = end - 1
+ }
+
+ if (listItem.type.startsWith('container') || listItem.type === 'uml_diagram') {
+ end++
+ }
+
+ return { start, end, kind: this.getFoldingRangeKind(listItem) }
+ })
+ }
+
+ private getFoldingRangeKind (listItem: Token): Monaco.languages.FoldingRangeKind | undefined {
+ return (listItem.type === 'comment' || (listItem.type === 'html_block' && listItem.content.startsWith('\n\n```\n' },
- { name: '``` Drawio', type: 'Drawio 图形', insertText: '```xml\n\n${1:}\n```\n' },
- { name: '[]() Drawio Link', type: 'Drawio 图形链接', insertText: '[${2:链接}]($1){link-type="drawio"}' },
- { name: '[]() Luckysheet Link', type: 'Luckysheet 链接', insertText: '[${2:链接}]($1){link-type="luckysheet"}' },
- { name: '```mermaid Mermaid', type: 'Mermaid 图形', insertText: '```mermaid\ngraph LR\n${1:A[Hard] -->|Text| B(Round)}\n```\n' },
- { name: '@startuml Plantuml', type: 'Plantuml 图形', insertText: '@startuml\n${1:a -> b}\n@enduml\n' },
- ].map(x => ({
- label: { name: x.name, type: x.type },
- kind: monaco.languages.CompletionItemKind.Snippet,
- insertText: x.insertText,
- insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
- range: range
- }))
-}
+import { getEditor, getOneIndent, insert, whenEditorReady } from '@fe/services/editor'
+import type { Plugin } from '@fe/context'
+import { t } from '@fe/services/i18n'
+import type { IMarkdownString } from 'monaco-editor'
export default {
name: 'editor-markdown',
- register: () => {
+ register: (ctx) => {
+ function insertDate () {
+ insert(dayjs().format('YYYY-MM-DD'))
+ }
+
+ function insertTime () {
+ insert(dayjs().format('HH:mm:ss'))
+ }
+
+ function revealLineInPreview () {
+ const line = getEditor().getPosition()?.lineNumber
+ if (line && ctx.doc.isSameFile(ctx.view.getRenderEnv()?.file, ctx.store.state.currentFile)) {
+ ctx.view.highlightLine(line, true, 1000)
+ }
+ }
+
+ function focusEditor () {
+ const line = getEditor().getPosition()?.lineNumber
+ if (line) {
+ ctx.view.disableSyncScrollAwhile(() => {
+ getEditor().revealLineInCenter(line)
+ getEditor().focus()
+ })
+ }
+ }
+
+ const idInsertTime = 'plugin.editor.insert-time'
+ const idInsertDate = 'plugin.editor.insert-date'
+ const idRevealLineInPreview = 'plugin.editor.reveal-line-in-preview'
+ const idForceInsertNewLine = 'plugin.editor.force-insert-new-line'
+ const idForceInsertIndent = 'plugin.editor.force-insert-indent'
+ const idRevealCurrentFileInOS = 'plugin.editor.reveal-current-file-in-os'
+ const idRefreshCurrentDoc = 'plugin.editor.refresh-current-document'
+
whenEditorReady().then(({ editor, monaco }) => {
const KM = monaco.KeyMod
const KC = monaco.KeyCode
editor.addAction({
- id: 'plugin.editor.insert-date',
- label: '插入当前日期',
+ id: idInsertDate,
+ label: t('editor.context-menu.insert-date'),
contextMenuGroupId: 'modification',
keybindings: [
- KM.Shift | KM.Alt | KC.KEY_D
+ KM.Shift | KM.Alt | KC.KeyD
],
- run: () => {
- insert(dayjs().format('YYYY-MM-DD'))
- }
+ run: insertDate
})
editor.addAction({
- id: 'plugin.editor.insert-time',
- label: '插入当前时间',
+ id: idInsertTime,
+ label: t('editor.context-menu.insert-time'),
contextMenuGroupId: 'modification',
keybindings: [
- KM.Shift | KM.Alt | KC.KEY_T
+ KM.Shift | KM.Alt | KC.KeyT
],
- run: () => {
- insert(dayjs().format('HH:mm:ss'))
- }
+ run: insertTime
})
- editor.addCommand(KM.CtrlCmd | KC.Enter, () => {
- insert(editor.getModel()!.getEOL())
+ editor.addAction({
+ id: idRevealLineInPreview,
+ label: t('editor.context-menu.reveal-line-in-preview'),
+ contextMenuGroupId: 'other',
+ keybindings: [KM.Alt | KC.KeyL],
+ run: revealLineInPreview
})
- editor.addCommand(KM.Shift | KC.Enter, () => {
- // getOneIndent 接口被移除了 https://github.com/microsoft/monaco-editor/issues/1565
- const getOneIndent = () => {
- const options = editor.getModel()!.getOptions()
- return options.insertSpaces ? ' '.repeat(options.tabSize) : '\t'
+ editor.addAction({
+ id: idForceInsertNewLine,
+ label: t('editor.context-menu.force-insert-new-line'),
+ contextMenuGroupId: 'modification',
+ keybindings: [KM.Alt | KC.Enter],
+ run: () => {
+ insert(editor.getModel()!.getEOL())
}
-
- insert(getOneIndent())
})
- editor.addCommand(KM.CtrlCmd | KM.Shift | KC.UpArrow, () => {
- editor.getAction('editor.action.moveLinesUpAction').run()
+ editor.addAction({
+ id: idForceInsertIndent,
+ label: t('editor.context-menu.force-insert-indent'),
+ contextMenuGroupId: 'modification',
+ keybindings: [KM.Shift | KC.Enter],
+ run: () => {
+ insert(getOneIndent())
+ }
})
- editor.addCommand(KM.CtrlCmd | KM.Shift | KC.DownArrow, () => {
- editor.getAction('editor.action.moveLinesDownAction').run()
- })
+ monaco.editor.addKeybindingRules([
+ {
+ command: 'editor.action.transformToUppercase',
+ keybinding: KM.chord(KM.CtrlCmd | KC.KeyK, KM.CtrlCmd | KC.KeyU),
+ when: 'editorTextFocus'
+ },
+ {
+ command: 'editor.action.transformToLowercase',
+ keybinding: KM.chord(KM.CtrlCmd | KC.KeyK, KM.CtrlCmd | KC.KeyL),
+ when: 'editorTextFocus'
+ }
+ ])
- editor.addCommand(KM.CtrlCmd | KM.Shift | KC.KEY_D, () => {
- editor.getAction('editor.action.copyLinesDownAction').run()
+ editor.onDidCompositionStart(() => {
+ ctx.store.state.inComposition = true
})
- editor.addCommand(KM.CtrlCmd | KC.KEY_J, () => {
- editor.getAction('editor.action.joinLines').run()
+ editor.onDidCompositionEnd(() => {
+ ctx.store.state.inComposition = false
})
- editor.addCommand(KM.chord(KM.CtrlCmd | KC.KEY_K, KM.CtrlCmd | KC.KEY_U), () => {
- editor.getAction('editor.action.transformToUppercase').run()
+ const messageContribution: any = editor.getContribution('editor.contrib.messageController')
+ editor.onDidAttemptReadOnlyEdit(() => {
+ const currentFile = ctx.store.state.currentFile
+ const cmdRevealCurrentFile = `command:vs.editor.ICodeEditor:1:${idRevealCurrentFileInOS}`
+ const cmdRefreshCurrentDoc = `command:vs.editor.ICodeEditor:1:${idRefreshCurrentDoc}`
+ const message =
+ ctx.args.FLAG_READONLY
+ ? ctx.i18n.t('read-only-mode-desc')
+ : !currentFile
+ ? ctx.i18n.t('file-status.no-file')
+ : currentFile.writeable === false
+ ? {
+ value: ctx.i18n.t('file-readonly-desc', cmdRevealCurrentFile, cmdRefreshCurrentDoc),
+ isTrusted: true,
+ } as IMarkdownString
+ : ctx.i18n.t('can-not-edit-this-file-type')
+ messageContribution.showMessage(message, editor.getPosition())
})
- editor.addCommand(KM.chord(KM.CtrlCmd | KC.KEY_K, KM.CtrlCmd | KC.KEY_L), () => {
- editor.getAction('editor.action.transformToLowercase').run()
+ editor.addAction({
+ id: idRevealCurrentFileInOS,
+ label: ctx.i18n.t('editor.action-label.reveal-current-file-in-os'),
+ run () {
+ const filePath = ctx.store.state.currentFile?.absolutePath
+ if (filePath) {
+ ctx.base.showItemInFolder(filePath)
+ }
+ }
})
- monaco.languages.setLanguageConfiguration('markdown', {
- onEnterRules: [
- { beforeText: /^\s*> .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '> ' } },
- { beforeText: /^\s*\+ \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
- { beforeText: /^\s*- \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
- { beforeText: /^\s*\* \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
- { beforeText: /^\s*\+ \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
- { beforeText: /^\s*- \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
- { beforeText: /^\s*\* \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
- { beforeText: /^\s*\+ .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ ' } },
- { beforeText: /^\s*- .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- ' } },
- { beforeText: /^\s*\* .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* ' } },
- { beforeText: /^\s*1. .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '1. ' } }
- ]
+ editor.addAction({
+ id: idRefreshCurrentDoc,
+ label: ctx.i18n.t('editor.action-label.refresh-current-document'),
+ run () {
+ ctx.view.refresh()
+ }
})
+ })
- monaco.languages.registerCompletionItemProvider('markdown', {
- triggerCharacters: Array(93).fill(undefined).map((_, i) => String.fromCharCode(i + 33)).concat(['~']),
- provideCompletionItems: (model, position) => {
- const lineContent = model.getLineContent(position.lineNumber)
- let startColumn = lineContent.substring(0, position.column).lastIndexOf(' ') + 1
- if (startColumn === position.column) {
- startColumn = 0
- }
-
- let endColumn = lineContent.substring(position.column - 1).indexOf(' ') + position.column
- if (endColumn < position.column) {
- endColumn = lineContent.length + 1
- }
-
- const range = {
- startLineNumber: position.lineNumber,
- endLineNumber: position.lineNumber,
- startColumn: startColumn + 1,
- endColumn: endColumn
- }
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push(
+ {
+ id: idInsertTime,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.insert-time'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idInsertTime) || []),
+ onClick: insertTime,
+ },
+ {
+ id: idInsertDate,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.insert-date'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idInsertDate) || []),
+ onClick: insertDate,
+ },
+ )
+ })
- return {
- suggestions: createDependencyProposals(range)
- }
- }
- })
+ ctx.action.registerAction({
+ name: 'plugin.editor.focus-editor',
+ description: ctx.i18n.t('command-desc.plugin_editor_focus-editor'),
+ handler: focusEditor,
+ forUser: true,
+ keys: [ctx.keybinding.Shift, ctx.keybinding.Alt, 'x']
})
}
} as Plugin
diff --git a/src/renderer/plugins/editor-md-list.ts b/src/renderer/plugins/editor-md-list.ts
new file mode 100644
index 000000000..4887e1539
--- /dev/null
+++ b/src/renderer/plugins/editor-md-list.ts
@@ -0,0 +1,329 @@
+import type * as Monaco from 'monaco-editor'
+import { getLineContent, getOneIndent } from '@fe/services/editor'
+import type { Plugin } from '@fe/context'
+import { getSetting } from '@fe/services/setting'
+import { isKeydown } from '@fe/core/keybinding'
+
+const emptyItemReg = /^\s*(?:[*+\->]|\d+[.)]|[*+-] \[ \])\s*$/
+const unorderedListReg = /^\s*[*+-]\s/
+const orderedListReg = /^(\s*)(\d+)([.)])(\s)/
+const emptyLineReg = /^\s*$/
+
+let ignoreTabProcess = false
+
+function processCursorChange (editor: Monaco.editor.IStandaloneCodeEditor, monaco: typeof Monaco, e: Monaco.editor.ICursorPositionChangedEvent) {
+ const model = editor.getModel()
+ if (e.reason !== 0 || !model) {
+ return
+ }
+
+ const source = 'list-completion'
+ const isTab = e.source === 'tab'
+ const isOutdent = e.source === 'outdent'
+ const isDeleteLeft = e.source === 'deleteLeft'
+ const isEnter = (e.source === 'keyboard' || e.source === 'editor.action.insertLineAfter') && isKeydown('ENTER')
+ const isSpace = e.source === 'keyboard' && isKeydown(' ')
+
+ if (!isTab && !isDeleteLeft && !isEnter && !isSpace && !isOutdent) {
+ return false
+ }
+
+ const cursorAtEnd = model.getLineMaxColumn(e.position.lineNumber) === e.position.column
+
+ const tryKeepCursorAtEnd = () => {
+ if (cursorAtEnd) {
+ // force set position to the end of line
+ editor.setPosition(new monaco.Position(e.position.lineNumber, model.getLineMaxColumn(e.position.lineNumber)))
+ }
+ }
+
+ const processTab = (position: Monaco.Position) => {
+ const currentLine = model.getLineContent(position.lineNumber)
+ if (!currentLine) {
+ return
+ }
+
+ const eolNumber = model.getLineMaxColumn(position.lineNumber)
+
+ if (
+ eolNumber === position.column &&
+ /^\s*(?:[*+\->]|\d+[.)])/.test(currentLine)
+ ) {
+ const indent = getOneIndent()
+ const val = currentLine.trimEnd()
+ const end = /[-+*\].>)]$/.test(val) ? ' ' : ''
+ editor.pushUndoStop()
+ editor.executeEdits(source, [
+ {
+ range: new monaco.Range(position.lineNumber, 1, position.lineNumber, eolNumber),
+ text: indent + val + end
+ },
+ ])
+ }
+ }
+
+ const processEnter = (position: Monaco.Position) => {
+ const line = position.lineNumber
+
+ if (line < 2) {
+ return
+ }
+
+ const content = getLineContent(line)
+ const prevContent = getLineContent(line - 1)
+ if (
+ emptyItemReg.test(content) && // current line content must a empty item
+ emptyItemReg.test(prevContent) // next line content must a empty item
+ ) {
+ editor.pushUndoStop()
+ editor.executeEdits(source, [
+ {
+ range: new monaco.Range(line - 1, 1, line, model.getLineMaxColumn(line)),
+ text: '',
+ forceMoveMarkers: true
+ }
+ ])
+ return true
+ }
+ }
+
+ if (isTab) {
+ if (!ignoreTabProcess) {
+ processTab(e.position)
+ tryKeepCursorAtEnd()
+ }
+ } else if (isEnter) {
+ if (processEnter(e.position)) {
+ return // skip auto ordered list completion
+ }
+ }
+
+ const orderedListCompletion = getSetting('editor.ordered-list-completion', 'auto')
+
+ if (orderedListCompletion === 'off') {
+ return
+ }
+
+ const maxLineCount = model.getLineCount()
+
+ const processOrderedList = (position: Monaco.Position) => {
+ const line = position.lineNumber
+ if (line < 2) {
+ return
+ }
+
+ let startLine = line - 1
+ let endLine = line + 1
+ const prevLines = []
+ const nextLines = []
+ const currentLine = model.getLineContent(line)
+ const prefix = currentLine.slice(0, position.column - 1)
+
+ // check current line is an ordered list item
+ const match = currentLine.match(orderedListReg)
+ if (!match) {
+ return
+ }
+
+ const indent = match[1]
+
+ // if press space key, only auto complete when cursor at the start of line
+ if (isSpace && !emptyItemReg.test(prefix)) {
+ return
+ }
+
+ // if press delete left key, only auto complete when cursor at the end of line
+ if (isDeleteLeft && model.getLineMaxColumn(line) !== position.column) {
+ return
+ }
+
+ // 1. outdent a <- break
+ // 1. aaa <- matched
+ // 2. bbb <- matched
+ // 1. bbb.aaa <- matched
+ // 2. bbb.bbb <- matched
+ // 3. ccc <- matched
+ // CCC <- matched
+ // 4. ddd <- [*]cursor here
+ // 5. eee <- matched
+ // 1. eee.aaa <- matched
+ // 6. ddd <- matched
+ // 2. outdent b <- break
+ const matchContent = (content: string) => {
+ if (emptyLineReg.test(content)) { // empty line
+ return false
+ }
+
+ if (unorderedListReg.test(content)) { // unordered list
+ return false
+ }
+
+ const m = content.match(orderedListReg)
+ if (m && m[1].length < indent.length) { // outdent
+ return false
+ }
+
+ return true
+ }
+
+ while (startLine > 0) {
+ const content = model.getLineContent(startLine)
+ if (!matchContent(content)) {
+ break
+ }
+
+ // if we are here, it means the line is ordered list item (same or deeper indent)
+ prevLines.unshift(content)
+ startLine--
+ }
+
+ startLine++
+
+ while (endLine <= maxLineCount) {
+ const content = model.getLineContent(endLine)
+ if (!matchContent(content)) {
+ break
+ }
+
+ // if we are here, it means the line is ordered list item (same or deeper indent)
+ nextLines.push(content)
+ endLine++
+ }
+
+ endLine--
+
+ // if orderedListCompletion is auto, only auto complete when previous 2 lines are ordered list item
+ if (orderedListCompletion === 'auto' && prevLines.length < 2) {
+ return
+ }
+
+ const firstLine = prevLines[0]
+ const firstMatch = firstLine ? firstLine.match(orderedListReg) : null
+ const startNum = firstMatch ? parseInt(firstMatch[2]) : 1
+ let shouldInc = orderedListCompletion === 'increase'
+
+ if (orderedListCompletion === 'auto') {
+ const secondLine = prevLines[1]
+ const secondMatch = secondLine ? secondLine.match(orderedListReg) : null
+ shouldInc = secondMatch ? parseInt(secondMatch[2]) > 1 : false
+ }
+
+ const changedLines: number[] = []
+ let seq = 0
+ const text = [...prevLines, currentLine, ...nextLines].map((line, i) => {
+ const replaced = line.replace(orderedListReg, (s, p1, p2, p3, p4) => {
+ if (p1 !== indent) {
+ return s
+ }
+
+ const num = shouldInc ? (seq++) + startNum : startNum
+ return `${p1}${num}${p3}${p4}`
+ })
+
+ if (replaced !== line) {
+ changedLines.push(i)
+ }
+
+ return replaced
+ })
+
+ if (!changedLines.length) {
+ return
+ }
+
+ const changedLineStart = changedLines[0]
+ const changedLineEnd = changedLines[changedLines.length - 1]
+
+ return {
+ text: text.slice(changedLineStart, changedLineEnd + 1),
+ startLine: startLine + changedLineStart,
+ endLine: startLine + changedLineEnd
+ }
+ }
+
+ const doEdits = (position: Monaco.Position) => {
+ const edits: Monaco.editor.IIdentifiedSingleEditOperation[] = [position].map(p => {
+ const result = processOrderedList(p)
+ if (!result) {
+ return null
+ }
+
+ return {
+ range: new monaco.Range(result.startLine, 1, result.endLine, model.getLineMaxColumn(result.endLine)),
+ text: result.text.join(model.getEOL()),
+ } satisfies Monaco.editor.IIdentifiedSingleEditOperation
+ }).filter(Boolean) as Monaco.editor.IIdentifiedSingleEditOperation[]
+
+ // apply edits
+ if (edits.length) {
+ editor.pushUndoStop()
+ editor.executeEdits(source, edits)
+ tryKeepCursorAtEnd()
+ }
+ }
+
+ doEdits(e.position)
+
+ // if press tab key, auto complete the next outdent line
+ if ((isTab || isOutdent)) {
+ // find the next outdent line
+ let outdentLine: number = 0
+ const lineCount = model.getLineCount()
+ const currentLine = model.getLineContent(e.position.lineNumber)
+ const currentLineIndent = currentLine.match(orderedListReg)?.[1]
+
+ if (typeof currentLineIndent !== 'string') return
+
+ let line = e.position.lineNumber + 1
+ while (line < lineCount) {
+ const content = model.getLineContent(line)
+ const m = content.match(orderedListReg)
+ if (!m) return
+
+ if (m[1].length < currentLineIndent.length) {
+ outdentLine = line
+ break
+ }
+
+ line++
+ }
+
+ if (outdentLine) {
+ doEdits(new monaco.Position(outdentLine, 1))
+ }
+ }
+}
+
+export default {
+ name: 'editor-md-list',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
+ editor.onDidChangeCursorPosition(e => {
+ processCursorChange(editor, monaco, e)
+ })
+
+ // ignore tab process when cursor at the start of line
+ editor.onKeyDown(e => {
+ ignoreTabProcess = false
+ if (e.keyCode === monaco.KeyCode.Tab && !e.shiftKey && !e.altKey) {
+ const position = editor.getPosition()
+ const model = editor.getModel()
+
+ if (position && model) {
+ // get before cursor content
+ const line = model.getValueInRange({
+ startLineNumber: position.lineNumber,
+ startColumn: 1,
+ endLineNumber: position.lineNumber,
+ endColumn: position.column
+ })
+
+ if (line.trim() === '') {
+ ignoreTabProcess = true
+ }
+ }
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-md-syntax.ts b/src/renderer/plugins/editor-md-syntax.ts
new file mode 100644
index 000000000..f042f42ae
--- /dev/null
+++ b/src/renderer/plugins/editor-md-syntax.ts
@@ -0,0 +1,278 @@
+/* eslint-disable no-template-curly-in-string */
+import type * as Monaco from 'monaco-editor'
+import type { Ctx, Plugin } from '@fe/context'
+
+const surroundingPairs = [
+ { open: '{', close: '}' },
+ { open: '[', close: ']' },
+ { open: '(', close: ')' },
+ { open: '<', close: '>' },
+ { open: '`', close: '`' },
+ { open: "'", close: "'" },
+ { open: '"', close: '"' },
+ { open: '*', close: '*' },
+ { open: '_', close: '_' },
+ { open: '=', close: '=' },
+ { open: '~', close: '~' },
+ { open: '^', close: '^' },
+ { open: '#', close: '#' },
+ { open: '$', close: '$' },
+ { open: '《', close: '》' },
+ { open: '〈', close: '〉' },
+ { open: '【', close: '】' },
+ { open: '「', close: '」' },
+ { open: '（', close: '）' },
+ { open: '“', close: '”' },
+]
+
+const autoClosingPairs = [
+ { open: '{', close: '}' },
+ { open: '[', close: ']' },
+ { open: '(', close: ')' },
+ { open: '《', close: '》' },
+ { open: '〈', close: '〉' },
+ { open: '【', close: '】' },
+ { open: '「', close: '」' },
+ { open: '（', close: '）' },
+]
+
+class MdSyntaxCompletionProvider implements Monaco.languages.CompletionItemProvider {
+ triggerCharacters = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'.split('')
+
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ private readonly pairsMap = new Map(surroundingPairs.map(x => [x.open, x.close]))
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ private getRangeColumnOffset (type: 'suffix' | 'prefix', line: string, insertText: string) {
+ if (!line || !insertText) {
+ return 0
+ }
+
+ insertText = insertText.replace(/\$\{[0-9]+:([^}]+)?\}/g, '$1')
+ .replace(/\$\[0-9]/g, '')
+
+ const len = Math.min(line.length, insertText.length)
+
+ if (type === 'suffix') {
+ for (let i = len; i >= 0; i--) {
+ if (line.startsWith(insertText.slice(insertText.length - i))) {
+ return i
+ }
+ }
+ } else {
+ for (let i = len; i >= 0; i--) {
+ if (line.endsWith(insertText.slice(0, i))) {
+ return i
+ }
+ }
+ }
+
+ return 0
+ }
+
+ private async provideSelectionCompletionItems (model: Monaco.editor.IModel, selection: Monaco.Selection, languageId: string): Promise {
+ const selectionEndLineMaxColumn = model.getLineMaxColumn(selection.endLineNumber)
+ const items = this.ctx.editor.getSimpleCompletionItems().filter(item => {
+ if (item.language && item.language !== languageId) {
+ return false
+ }
+
+ if (item.insertText.includes('${TM_SELECTED_TEXT}')) {
+ return true
+ }
+
+ const surroundSelectionSnippet = typeof item.surroundSelection === 'function'
+ ? item.surroundSelection(item.insertText, selection, model)
+ : typeof item.surroundSelection === 'string'
+ ? item.insertText.replace(item.surroundSelection, '$TM_SELECTED_TEXT')
+ : undefined
+
+ if (surroundSelectionSnippet) {
+ const allowBlock = selection.startColumn === 1 && selection.endColumn === selectionEndLineMaxColumn
+ item.insertText = surroundSelectionSnippet
+
+ if (item.block && !allowBlock) {
+ return false
+ }
+
+ return true
+ }
+
+ return false
+ })
+
+ const result: Monaco.languages.CompletionItem[] = items.map((item, i) => {
+ const range = new this.monaco.Range(
+ selection.startLineNumber,
+ selection.startColumn,
+ selection.endLineNumber,
+ selection.endColumn,
+ )
+
+ return {
+ label: { label: item.label },
+ kind: item.kind || this.monaco.languages.CompletionItemKind.Keyword,
+ insertText: item.insertText,
+ insertTextRules: this.monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+ range: this.monaco.Range.spansMultipleLines(range) ? range.collapseToStart() : range,
+ sortText: i.toString().padStart(7),
+ detail: item.detail,
+ }
+ })
+
+ return { suggestions: result }
+ }
+
+ public async provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Promise {
+ const languageId = this.ctx.editor.getLineLanguageId(position.lineNumber, model)
+
+ const selection = this.ctx.editor.getEditor().getSelection()!
+ if (!selection.isEmpty()) {
+ return this.provideSelectionCompletionItems(model, selection, languageId)
+ }
+
+ const line = model.getLineContent(position.lineNumber)
+ const cursor = position.column - 1
+ const linePrefixText = line.slice(0, cursor)
+ const lineSuffixText = line.slice(cursor)
+
+ let startColumn = linePrefixText.lastIndexOf(' ') + 2
+ if (startColumn === position.column) {
+ startColumn = 0
+ }
+
+ const items = this.ctx.editor.getSimpleCompletionItems().filter((item) => {
+ if (item.language && item.language !== languageId) {
+ return false
+ }
+
+ return !item.block || startColumn === 1
+ })
+
+ const result: Monaco.languages.CompletionItem[] = items.map((item, i) => {
+ let columnOffset = this.getRangeColumnOffset('suffix', lineSuffixText, item.insertText)
+ if (columnOffset === 0) {
+ // remove auto surrounding pairs
+ columnOffset = this.pairsMap.get(line.charAt(cursor - 1)) === line.charAt(cursor) ? 1 : 0
+ }
+
+ const range = new this.monaco.Range(
+ position.lineNumber,
+ startColumn,
+ position.lineNumber,
+ position.column + columnOffset,
+ )
+
+ return {
+ label: { label: item.label },
+ kind: item.kind || this.monaco.languages.CompletionItemKind.Keyword,
+ insertText: item.insertText,
+ insertTextRules: this.monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+ range,
+ sortText: i.toString().padStart(7),
+ detail: item.detail,
+ command: item.command,
+ }
+ })
+
+ return { suggestions: result }
+ }
+}
+
+export default {
+ name: 'editor-md-syntax',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new MdSyntaxCompletionProvider(monaco, ctx)
+ )
+
+ monaco.languages.setLanguageConfiguration('markdown', {
+ surroundingPairs,
+ autoClosingPairs,
+ onEnterRules: [
+ { beforeText: /^\s*> .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '> ' } },
+ { beforeText: /^\s*\+ \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
+ { beforeText: /^\s*- \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
+ { beforeText: /^\s*\* \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
+ { beforeText: /^\s*\+ \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
+ { beforeText: /^\s*- \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
+ { beforeText: /^\s*\* \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
+ { beforeText: /^\s*\+ .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ ' } },
+ { beforeText: /^\s*- .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- ' } },
+ { beforeText: /^\s*\* .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* ' } },
+ { beforeText: /^\s*\d+\. .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: { toString: () => ctx.setting.getSetting('editor.ordered-list-completion') === 'off' ? '' : '1. ' } as string } },
+ { beforeText: /^\s*\d+\) .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: { toString: () => ctx.setting.getSetting('editor.ordered-list-completion') === 'off' ? '' : '1) ' } as string } },
+ ]
+ })
+
+ monaco.languages.registerCodeActionProvider('*', {
+ provideCodeActions (_model: Monaco.editor.ITextModel, range: Monaco.Range): Monaco.languages.CodeActionList {
+ const enabled = ctx.setting.getSetting('editor.enable-trigger-suggest-bulb', true)
+ if (!enabled || range.isEmpty() || (range as Monaco.Selection).getDirection?.() === monaco.SelectionDirection.LTR) {
+ return { dispose: () => 0, actions: [] }
+ }
+
+ const actionTitle = ctx.i18n.t('trigger-suggestions')
+ const actionId = 'editor.action.triggerSuggest'
+
+ const actions: Monaco.languages.CodeAction[] = [{
+ title: actionTitle,
+ command: { id: actionId, title: actionTitle },
+ kind: 'refactor',
+ diagnostics: [],
+ isPreferred: true,
+ }]
+
+ return { dispose: () => 0, actions }
+ },
+ })
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ items.unshift(
+ { language: 'markdown', label: '/ ![]() Image', insertText: '' },
+ { language: 'markdown', label: '/ []() Link', insertText: '[${2:Link}]($1)' },
+ { language: 'markdown', label: '/ # Head 1', insertText: '# $1', block: true },
+ { language: 'markdown', label: '/ ## Head 2', insertText: '## $1', block: true },
+ { language: 'markdown', label: '/ ### Head 3', insertText: '### $1', block: true },
+ { language: 'markdown', label: '/ #### Head 4', insertText: '#### $1', block: true },
+ { language: 'markdown', label: '/ ##### Head 5', insertText: '##### $1', block: true },
+ { language: 'markdown', label: '/ ###### Head 6', insertText: '###### $1', block: true },
+ { language: 'markdown', label: '/ + List', insertText: '+ ' },
+ { language: 'markdown', label: '/ - List', insertText: '- ' },
+ { language: 'markdown', label: '/ > Blockquote', insertText: '> ' },
+ { language: 'markdown', label: '/ ` Code', insertText: '`$1`', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ * Italic', insertText: '*$1*', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ _ Italic', insertText: '_$1_', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ~ Sub', insertText: '~$1~', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ^ Sup', insertText: '^$1^', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ** Bold', insertText: '**$1**', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ __ Bold', insertText: '__$1__', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ~~ Delete', insertText: '~~$1~~', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ == Mark', insertText: '==$1==', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ``` Fence', insertText: '```$1\n$2\n```\n', block: true, surroundSelection: '$2', },
+ { language: 'markdown', label: '/ --- Horizontal Line', insertText: '---\n', block: true },
+ { language: 'markdown', label: '/ + [ ] TODO List', insertText: '+ [ ] ' },
+ { language: 'markdown', label: '/ - [ ] TODO List', insertText: '- [ ] ' },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/^\s*[+\-*] \[[ xX]\]\s/, 'keyword'],
+ [/==\S.*?\S?==/, 'keyword'],
+ [/(!?\[\[)([^[\]]+)(\]\])/, ['keyword.predefined', 'string', 'keyword.predefined']],
+ [/~\S[^~]*\S?~/, 'string'],
+ [/\^\S[^^]*\S?\^/, 'string'],
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-paste.ts b/src/renderer/plugins/editor-paste.ts
index a75184b91..5cc5c665d 100644
--- a/src/renderer/plugins/editor-paste.ts
+++ b/src/renderer/plugins/editor-paste.ts
@@ -1,49 +1,65 @@
+import dayjs from 'dayjs'
import TurndownService from 'turndown'
-import { getEditor, insert } from '@fe/context/editor'
-import type { Plugin } from '@fe/context/plugin'
-import * as api from '@fe/support/api'
+import { gfm } from 'joplin-turndown-plugin-gfm'
+import { getEditor, insert } from '@fe/services/editor'
+import { Plugin } from '@fe/context'
+import { triggerHook } from '@fe/core/hook'
+import { refreshTree } from '@fe/services/tree'
+import { upload } from '@fe/services/base'
import store from '@fe/support/store'
-import { encodeMarkdownLink, fileToBase64URL } from '@fe/utils'
+import { encodeMarkdownLink, fileToBase64URL, path } from '@fe/utils'
+import { isKeydown } from '@fe/core/keybinding'
-let keys: {[key: string]: boolean} = {}
-
-function recordKeys (e: KeyboardEvent) {
- if (e.type === 'keydown') {
- keys[e.key] = true
- } else {
- keys = {}
- }
-}
+const IMAGE_REG = /^image\//i
+const HTML_REG = /^text\/html$/i
async function pasteHtml (html: string) {
- const md = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced', bulletListMarker: '+' }).turndown(html)
- insert(md)
+ const td = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced', bulletListMarker: '+' })
+ td.use(gfm)
+ const md = td.turndown(html)
+ insert(md + '\n')
}
-async function pasteImage (file: any, asBase64: boolean) {
+async function pasteImage (file: File, asBase64: boolean) {
if (asBase64) {
const uri = await fileToBase64URL(file)
- insert(`\n`)
+ insert(`\n`)
} else {
if (!store.state.currentFile) {
- throw new Error('当前未打开文件')
+ throw new Error('No file opened.')
}
- const { repo, path } = store.state.currentFile
- const { relativePath } = await api.upload(repo, path, file)
- insert(`})\n`)
+ const ext = path.extname(file.name)
+ const filename = `img-${dayjs().format('YYYYMMDDHHmmss')}${ext}`
+
+ file = new File([file], filename, { type: file.type })
+
+ if (!(await triggerHook('EDITOR_PASTE_IMAGE', { file }, { breakable: true }))) {
+ const assetPath = await upload(file, store.state.currentFile, file.name)
+ insert(`})\n`)
+ }
+
+ refreshTree()
}
}
+let selectedTextBeforePaste = ''
+
function paste (e: ClipboardEvent) {
- if (!getEditor().hasTextFocus()) {
+ selectedTextBeforePaste = ''
+ const editor = getEditor()
+ if (!editor.hasTextFocus()) {
return
}
- const items = e.clipboardData!.items
- if (keys.d || keys.D) { // 粘贴 HTML 转为 markdown
+ if (e.clipboardData === null) {
+ return
+ }
+
+ const items = e.clipboardData.items
+ if (isKeydown('D')) { // covert RFT to markdown
for (let i = 0; i < items.length; i++) {
- if (items[i].type.match(/^text\/html$/i)) {
+ if (items[i].type.match(HTML_REG)) {
items[i].getAsString(pasteHtml)
}
}
@@ -53,19 +69,177 @@ function paste (e: ClipboardEvent) {
} else {
for (let i = 0; i < items.length; i++) {
const fileType = items[i].type
- if (fileType.match(/^image\/(png|jpg|jpeg|gif)$/i)) {
- const asBase64 = keys.b || keys.B // 粘贴的同时 按下了 B 键，就粘贴 base64 图像
- pasteImage(items[i].getAsFile(), asBase64)
+ if (IMAGE_REG.test(fileType)) {
+ e.preventDefault()
+ e.stopPropagation()
+ const asBase64 = isKeydown('B') // press key b, paste image as base64
+ pasteImage(items[i].getAsFile()!, asBase64)
}
}
}
+
+ // normal paste
+ // only one selection
+ if (editor.getSelections()?.length === 1) {
+ const selection = editor.getSelection()
+ if (selection && !selection.isEmpty()) {
+ selectedTextBeforePaste = editor.getModel()?.getValueInRange(selection) || ''
+ }
+ }
}
export default {
name: 'editor-paste',
- register: () => {
+ register: (ctx) => {
window.addEventListener('paste', paste as any, true)
- window.addEventListener('keydown', recordKeys, true)
- window.addEventListener('keyup', recordKeys, true)
+
+ const pasteImageAsBase64ActionId = 'plugin.editor-paste.insert-image-base64'
+ const pasteRtfActionId = 'plugin.editor-paste.insert-rt'
+
+ const pasteImageFromClipboard = async (asBase64: boolean) => {
+ ctx.base.readFromClipboard(async (type, getType) => {
+ if (IMAGE_REG.test(type)) {
+ const ext = ctx.lib.mime.getExtension(type)
+ const file = new File([await getType(type)], 'image.' + ext, { type })
+ await pasteImage(file, asBase64)
+ const { editor } = await ctx.editor.whenEditorReady()
+ editor.focus()
+ }
+ })
+ }
+
+ const pasteRtf = () => {
+ ctx.base.readFromClipboard(async (type, getType) => {
+ if (type.match(HTML_REG)) {
+ const html = await (await getType(type)).text()
+ await pasteHtml(html)
+ const { editor } = await ctx.editor.whenEditorReady()
+ editor.focus()
+ }
+ })
+ }
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push(
+ {
+ id: pasteImageAsBase64ActionId,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.insert.paste-img-base64'),
+ subTitle: 'Base64',
+ onClick: () => {
+ pasteImageFromClipboard(true)
+ }
+ },
+ {
+ id: pasteRtfActionId,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.insert.paste-rt'),
+ subTitle: 'Markdown',
+ onClick: pasteRtf
+ },
+ { type: 'separator' },
+ )
+ })
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.addAction({
+ id: 'plugin.editor-paste.insert-image',
+ label: ctx.i18n.t('editor.context-menu.paste-image'),
+ contextMenuGroupId: 'clipboard',
+ contextMenuOrder: 1,
+ run: async () => {
+ pasteImageFromClipboard(false)
+ }
+ })
+
+ editor.addAction({
+ id: pasteImageAsBase64ActionId,
+ label: ctx.i18n.t('editor.context-menu.paste-image-as-base64'),
+ contextMenuGroupId: 'clipboard',
+ contextMenuOrder: 2,
+ run: () => {
+ pasteImageFromClipboard(true)
+ }
+ })
+
+ editor.addAction({
+ id: pasteRtfActionId,
+ label: ctx.i18n.t('editor.context-menu.paste-rt-as-markdown'),
+ contextMenuGroupId: 'clipboard',
+ contextMenuOrder: 3,
+ run: pasteRtf,
+ })
+
+ editor.onDidPaste(({ range }) => {
+ const model = editor.getModel()
+ const languageId = model?.getLanguageId()
+ const parsedText = model?.getValueInRange(range) || ''
+
+ // paste link as markdown link
+ if (selectedTextBeforePaste && languageId === 'markdown' && !selectedTextBeforePaste.includes('\n')) {
+ const isLink = (str: string) => {
+ if (!/^https?:\/\//i.test(str)) {
+ return false
+ }
+
+ try {
+ // eslint-disable-next-line no-new
+ new URL(str)
+ return true
+ } catch (_) {
+ return false
+ }
+ }
+
+ const parsedTextIsLink = isLink(parsedText)
+ const selectedTextBeforePasteIsLink = isLink(selectedTextBeforePaste)
+
+ // both are link, do nothing
+ if (parsedTextIsLink && selectedTextBeforePasteIsLink) {
+ return
+ }
+
+ // is link
+ if (parsedText && parsedTextIsLink) {
+ const text = `[${
+ selectedTextBeforePaste.replace(/([[\]])/g, '\\$1')
+ }](${encodeMarkdownLink(parsedText)})`
+ editor.executeEdits('paste', [{ range, text }])
+ return
+ } else if (selectedTextBeforePasteIsLink) {
+ const text = `[${
+ parsedText.replace(/([[\]])/g, '\\$1').trim()
+ }](${encodeMarkdownLink(selectedTextBeforePaste)})`
+ editor.executeEdits('paste', [{ range, text }])
+ return
+ }
+ }
+
+ // paste splitted by tab as table
+ if (languageId === 'markdown') {
+ const lines = parsedText.replace(/^\n+|\n+$/g, '').split('\n')
+ if (lines.length > 2) {
+ let rows = []
+ for (const line of lines) {
+ const columns = line.split('\t')
+ if (columns.length >= 2) {
+ rows.push(`| ${columns.join(' | ')} |`)
+ } else {
+ rows = []
+ break
+ }
+ }
+
+ if (rows.length > 1) {
+ // add header
+ rows.splice(1, 0, rows[0].replace(/[^|]+/g, ' -- '))
+ editor.executeEdits('paste', [{ range, text: rows.join('\n') }])
+ }
+ }
+ }
+
+ selectedTextBeforePaste = ''
+ })
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/editor-path-completion.ts b/src/renderer/plugins/editor-path-completion.ts
new file mode 100644
index 000000000..94f6bd233
--- /dev/null
+++ b/src/renderer/plugins/editor-path-completion.ts
@@ -0,0 +1,459 @@
+// https://github.com/microsoft/vscode/blob/main/extensions%2Fmarkdown-language-features%2Fsrc%2Ffeatures%2FpathCompletions.ts
+
+import type Markdown from 'markdown-it'
+import type * as Monaco from 'monaco-editor'
+import type { Ctx, Plugin } from '@fe/context'
+import type { Components } from '@fe/types'
+import type Token from 'markdown-it/lib/token'
+import { MARKDOWN_FILE_EXT } from '@share/misc'
+
+enum CompletionContextKind {
+ Link, // [...](|)
+
+ WikiLink, // [[|]]
+
+ ReferenceLink, // [...][|]
+
+ LinkDefinition, // []: | // TODO: not implemented
+}
+
+interface AnchorContext {
+ /**
+ * Link text before the `#`.
+ *
+ * For `[text](xy#z|abc)` this is `xy`.
+ */
+ readonly beforeAnchor: string;
+ /**
+ * Text of the anchor before the current position.
+ *
+ * For `[text](xy#z|abc)` this is `z`.
+ */
+ readonly anchorPrefix: string;
+}
+
+interface CompletionContext {
+ readonly kind: CompletionContextKind;
+
+ /**
+ * Text of the link before the current position
+ *
+ * For `[text](xy#z|abc)` this is `xy#z`.
+ */
+ readonly linkPrefix: string;
+
+ /**
+ * Position of the start of the link.
+ *
+ * For `[text](xy#z|abc)` this is the position before `xy`.
+ */
+ readonly linkTextStartPosition: Monaco.Position;
+
+ /**
+ * Text of the link after the current position.
+ *
+ * For `[text](xy#z|abc)` this is `abc`.
+ */
+ readonly linkSuffix: string;
+
+ /**
+ * Info if the link looks like it is for an anchor: `[](#header)`
+ */
+ readonly anchorInfo?: AnchorContext;
+}
+
+class CompletionProvider implements Monaco.languages.CompletionItemProvider {
+ triggerCharacters = ['/', ':', '#', '[']
+
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+ private readonly markdown: Markdown
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ // eslint-disable-next-line new-cap
+ this.markdown = new ctx.lib.markdownit()
+ }
+
+ public async provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Promise {
+ const context = this.getPathCompletionContext(model, position)
+ if (!context) {
+ return { suggestions: [] }
+ }
+
+ switch (context.kind) {
+ case CompletionContextKind.ReferenceLink: {
+ return {
+ suggestions: Array.from(
+ this.provideReferenceSuggestions(this.ctx.view.getRenderEnv()?.source || model.getValue(), position, context)
+ )
+ }
+ }
+
+ case CompletionContextKind.LinkDefinition:
+ case CompletionContextKind.WikiLink:
+ case CompletionContextKind.Link: {
+ const items: Monaco.languages.CompletionItem[] = []
+
+ const isAnchorInCurrentDoc = context.anchorInfo && context.anchorInfo.beforeAnchor.length === 0
+
+ // Add anchor #links in current doc
+ if (context.linkPrefix.length === 0 || isAnchorInCurrentDoc) {
+ const insertRange = new this.monaco.Range(
+ context.linkTextStartPosition.lineNumber,
+ context.linkTextStartPosition.column,
+ position.lineNumber,
+ position.column
+ )
+
+ const tokens = this.ctx.view.getRenderEnv()?.tokens || []
+
+ for await (const item of this.provideHeaderSuggestions(tokens, context, position, insertRange)) {
+ items.push(item)
+ }
+ }
+
+ if (!isAnchorInCurrentDoc) {
+ if (context.anchorInfo) { // Anchor to a different document
+ const currentFile = this.ctx.store.state.currentFile
+ if (!currentFile || !context.anchorInfo.beforeAnchor.endsWith(MARKDOWN_FILE_EXT)) {
+ return { suggestions: [] }
+ }
+
+ const filePath = this.ctx.utils.path.resolve(
+ this.ctx.utils.path.dirname(currentFile.path),
+ context.anchorInfo.beforeAnchor
+ )
+
+ const { content } = await this.ctx.api.readFile({ repo: currentFile.repo, path: filePath })
+ if (content) {
+ const anchorStartPosition = position.delta(0, -(context.anchorInfo.anchorPrefix.length + 1))
+ const range = new this.monaco.Range(
+ anchorStartPosition.lineNumber,
+ anchorStartPosition.column,
+ position.lineNumber,
+ position.column,
+ )
+
+ for await (const item of this.provideHeaderSuggestions(content, context, position, range)) {
+ items.push(item)
+ }
+ }
+ } else { // Normal path suggestions
+ for await (const item of this.providePathSuggestions(position, context)) {
+ items.push(item)
+ }
+ }
+ }
+
+ return { suggestions: items }
+ }
+ }
+ }
+
+ /// [...](...|
+ private readonly linkStartPattern = /\[([^\]]*?)\]\(\s*([^\s()]*)$/
+
+ /// [[...|
+ private readonly wikiLinkStartPattern = /\[\[\s*([^[\]]*)$/
+
+ /// [...|
+ private readonly referenceLinkStartPattern = /\[\s*([^\s[\]]*)$/
+
+ /// [id]: |
+ private readonly definitionPattern = /^\s*\[[\w-]+\]:\s*([^\s]*)$/m
+
+ private readonly defPattern = /^([\t ]*\[(?!\^)((?:\\\]|[^\]])+)\]:\s*)([^<]\S*|<[^>]+>)/gm
+
+ private readonly angleBracketLinkRe = /^<(.*)>$/
+
+ private getPathCompletionContext (model: Monaco.editor.IModel, position: Monaco.Position): CompletionContext | undefined {
+ const line = model.getLineContent(position.lineNumber)
+
+ const cursor = position.column - 1
+ const linePrefixText = line.slice(0, cursor)
+ const lineSuffixText = line.slice(cursor)
+
+ const linkPrefixMatch = linePrefixText.match(this.linkStartPattern)
+ if (linkPrefixMatch) {
+ const prefix = linkPrefixMatch[2]
+ if (this.refLooksLikeUrl(prefix)) {
+ return undefined
+ }
+
+ const suffix = lineSuffixText.match(/^[^)\s]*/)
+
+ return {
+ kind: CompletionContextKind.Link,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ anchorInfo: this.getAnchorContext(prefix),
+ }
+ }
+
+ const wikiLinkPrefixMatch = linePrefixText.match(this.wikiLinkStartPattern)
+ if (wikiLinkPrefixMatch) {
+ const prefix = wikiLinkPrefixMatch[1]
+ const suffix = lineSuffixText.match(/^[^\]]*/)
+ return {
+ kind: CompletionContextKind.WikiLink,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ anchorInfo: this.getAnchorContext(prefix),
+ }
+ }
+
+ const definitionLinkPrefixMatch = linePrefixText.match(this.definitionPattern)
+ if (definitionLinkPrefixMatch) {
+ const prefix = definitionLinkPrefixMatch[1]
+ if (this.refLooksLikeUrl(prefix)) {
+ return undefined
+ }
+
+ const suffix = lineSuffixText.match(/^[^\s]*/)
+ return {
+ kind: CompletionContextKind.LinkDefinition,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ anchorInfo: this.getAnchorContext(prefix),
+ }
+ }
+
+ const referenceLinkPrefixMatch = linePrefixText.match(this.referenceLinkStartPattern)
+ if (referenceLinkPrefixMatch) {
+ const prefix = referenceLinkPrefixMatch[1]
+ const suffix = lineSuffixText.match(/^[^\]\s]*/)
+ return {
+ kind: CompletionContextKind.ReferenceLink,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ }
+ }
+
+ return undefined
+ }
+
+ /**
+ * Check if {@param ref} looks like a 'http:' style url.
+ */
+ private refLooksLikeUrl (prefix: string): boolean {
+ return /^\s*[\w\d-]+:/.test(prefix)
+ }
+
+ private getAnchorContext (prefix: string): AnchorContext | undefined {
+ const anchorMatch = prefix.match(/^(.*)#([\w\d-]*)$/)
+ if (!anchorMatch) {
+ return undefined
+ }
+
+ let beforeAnchor = anchorMatch[1]
+
+ if (anchorMatch[1] && !this.ctx.utils.path.extname(beforeAnchor)) {
+ beforeAnchor += MARKDOWN_FILE_EXT
+ }
+
+ return {
+ beforeAnchor,
+ anchorPrefix: anchorMatch[2],
+ }
+ }
+
+ private async * providePathSuggestions (position: Monaco.Position, context: CompletionContext): AsyncIterable {
+ let idx = context.linkPrefix.lastIndexOf('/')
+
+ if (context.kind === CompletionContextKind.WikiLink) {
+ idx = Math.max(context.linkPrefix.lastIndexOf(':'), idx)
+ }
+
+ const valueBeforeLastSlash = context.linkPrefix.substring(0, idx + 1) // keep the last slash
+
+ const currentFile = this.ctx.store.state.currentFile
+ if (!currentFile) {
+ return
+ }
+
+ const basePath = this.ctx.utils.path.dirname(currentFile.path)
+
+ const parentDir = context.kind === CompletionContextKind.WikiLink
+ ? this.ctx.utils.path.resolve(basePath, valueBeforeLastSlash.replace(/:/g, '/') || '.')
+ : this.ctx.utils.path.resolve(basePath, valueBeforeLastSlash || '.')
+
+ const pathSegmentStart = position.delta(0, valueBeforeLastSlash.length - context.linkPrefix.length)
+ const insertRange = new this.monaco.Range(
+ pathSegmentStart.lineNumber,
+ pathSegmentStart.column,
+ position.lineNumber,
+ position.column
+ )
+
+ const pathSegmentEnd = position.delta(0, context.linkSuffix.length)
+ const replacementRange = new this.monaco.Range(
+ pathSegmentStart.lineNumber,
+ pathSegmentStart.column,
+ pathSegmentEnd.lineNumber,
+ pathSegmentEnd.column,
+ )
+
+ const items = await this.getFileList(parentDir)
+
+ let i = 0
+ for (const item of items) {
+ i++
+ const isDir = item.type === 'dir'
+ let label = isDir ? item.name + '/' : item.name
+ let insertText = this.ctx.utils.encodeMarkdownLink(label)
+
+ // Remove extension for wiki links
+ if (context.kind === CompletionContextKind.WikiLink) {
+ label = label.replace(/\.(md|markdown)$/, '')
+ insertText = label.replaceAll(']', ']').replaceAll('[', '[')
+ }
+
+ yield {
+ label,
+ insertText,
+ kind: isDir ? this.monaco.languages.CompletionItemKind.Folder : this.monaco.languages.CompletionItemKind.File,
+ range: {
+ insert: insertRange,
+ replace: replacementRange,
+ },
+ command: isDir ? { id: 'editor.action.triggerSuggest', title: '' } : undefined,
+ sortText: i.toString().padStart(7),
+ }
+ }
+ }
+
+ private async getFileList (parentDir: string): Promise {
+ const result: Components.Tree.Node[] = []
+
+ const traverseTree = (nodes: Components.Tree.Node[]) => {
+ nodes.forEach(node => {
+ if (node.type === 'dir') {
+ if (parentDir.startsWith(node.path)) {
+ traverseTree(node.children || [])
+
+ if (node.path === parentDir) {
+ result.push(...(node.children || []))
+ }
+ }
+ }
+ })
+ }
+
+ const repo = this.ctx.store.state.currentFile?.repo
+
+ if (!repo) {
+ return result
+ }
+
+ if (this.ctx.store.state.currentFile?.repo === this.ctx.store.state.currentRepo?.name) {
+ traverseTree(this.ctx.store.state.tree || [])
+ } else {
+ const tree = await this.ctx.api.fetchTree(repo, { by: 'name', order: 'asc' }, undefined, true)
+ traverseTree(tree)
+ }
+
+ return result
+ }
+
+ private async * provideHeaderSuggestions (tokensOrContent: string | Token[], context: CompletionContext, position: Monaco.Position, insertionRange: Monaco.Range): AsyncIterable {
+ const tokens = typeof tokensOrContent === 'string' ? this.markdown.parse(tokensOrContent, []) : tokensOrContent
+ const endPos = position.delta(0, context.linkSuffix.length)
+ const replacementRange = new this.monaco.Range(
+ insertionRange.startLineNumber,
+ insertionRange.startColumn,
+ endPos.lineNumber,
+ endPos.column
+ )
+
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i]
+ if (token.type === 'heading_open') {
+ const nextToken = tokens[i + 1]
+ if (nextToken && nextToken.content) {
+ const id = nextToken.content.trim().replace(/\s+/g, '-')
+ yield {
+ kind: this.monaco.languages.CompletionItemKind.Reference,
+ label: '# ' + tokens[i].tag.toUpperCase() + ' ' + nextToken.content,
+ insertText: '#' + this.ctx.utils.encodeMarkdownLink(id),
+ range: {
+ insert: insertionRange,
+ replace: replacementRange,
+ },
+ sortText: i.toString().padStart(7)
+ }
+ }
+ }
+ }
+ }
+
+ private * provideReferenceSuggestions (text: string, position: Monaco.Position, context: CompletionContext): Iterable {
+ const insertionRange = new this.monaco.Range(
+ context.linkTextStartPosition.lineNumber,
+ context.linkTextStartPosition.column,
+ position.lineNumber,
+ position.column,
+ )
+
+ const replacementPos = position.delta(0, context.linkSuffix.length)
+
+ const replacementRange = new this.monaco.Range(
+ insertionRange.startLineNumber,
+ insertionRange.startColumn,
+ replacementPos.lineNumber,
+ replacementPos.column,
+ )
+
+ const definitions = this.getDefinitions(text)
+ let i = 0
+ for (const def of definitions) {
+ i++
+ yield {
+ kind: this.monaco.languages.CompletionItemKind.Reference,
+ label: def[0],
+ insertText: def[0],
+ range: {
+ insert: insertionRange,
+ replace: replacementRange,
+ },
+ sortText: i.toString().padStart(7)
+ }
+ }
+ }
+
+ private getDefinitions (text: string) {
+ const out = new Map()
+ for (const match of text.matchAll(this.defPattern)) {
+ const reference = match[2]
+ const link = match[3].trim()
+
+ if (this.angleBracketLinkRe.test(link)) {
+ out.set(reference, {
+ link: link.substring(1, link.length - 1),
+ })
+ } else {
+ out.set(reference, {
+ link,
+ })
+ }
+ }
+ return out
+ }
+}
+
+export default {
+ name: 'editor-md-completion',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new CompletionProvider(monaco, ctx)
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-restore-state.ts b/src/renderer/plugins/editor-restore-state.ts
new file mode 100644
index 000000000..ba1982d81
--- /dev/null
+++ b/src/renderer/plugins/editor-restore-state.ts
@@ -0,0 +1,87 @@
+import type { Plugin } from '@fe/context'
+import { registerHook } from '@fe/core/hook'
+import type { editor } from 'monaco-editor'
+
+export default {
+ name: 'editor-restore-state',
+ register: (ctx) => {
+ const logger = ctx.utils.getLogger('plugin:editor-restore-state')
+ const storageKey = 'plugin.editor-state'
+
+ const viewStateCache = ctx.lib.vue.shallowReactive>(ctx.storage.get(storageKey, {}))
+
+ ctx.lib.vue.watch(viewStateCache, () => {
+ // keep recent 10 view states
+ const entries = Object.entries(viewStateCache)
+ .sort((a, b) => b[1]._t - a[1]._t)
+ .slice(0, 10)
+
+ ctx.storage.set(storageKey, Object.fromEntries(entries))
+ })
+
+ function saveState (uri: editor.ITextModel['uri'] | null | undefined, viewState: editor.ICodeEditorViewState | null) {
+ if (!uri) return
+
+ const uriStr = uri.toString()
+ logger.debug('save view state', uriStr)
+ viewStateCache[uriStr] = {
+ _t: Date.now(),
+ v: viewState
+ }
+ }
+
+ const saveStateDebounced = ctx.lib.lodash.debounce(saveState, 500)
+
+ registerHook('DOC_BEFORE_SWITCH', () => {
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ const uri = editor.getModel()?.uri
+ if (!uri) return
+ const viewState = editor.saveViewState()
+ saveState(uri, viewState)
+ })
+ })
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.onDidChangeModel((e) => {
+ const uri = e.newModelUrl?.toString()
+ if (!uri) return
+ const viewState = viewStateCache[uri]
+ if (viewState && viewState.v) {
+ logger.debug('restore view state', uri)
+ editor.restoreViewState(viewState.v)
+ }
+ })
+
+ editor.onDidChangeCursorPosition(() => {
+ saveStateDebounced(editor.getModel()?.uri, editor.saveViewState())
+ })
+
+ editor.onDidScrollChange(() => {
+ saveStateDebounced(editor.getModel()?.uri, editor.saveViewState())
+ })
+ })
+
+ ctx.lib.vue.watch(() => ctx.store.state.tabs, () => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ const uris = ctx.store.state.tabs.map(x => x.key)
+
+ // clean view state
+ for (const uri of Object.keys(viewStateCache)) {
+ if (!uris.includes(uri)) {
+ logger.debug('dispose view state', uri)
+ delete viewStateCache[uri]
+ }
+ }
+
+ // clean models
+ const models = monaco.editor.getModels()
+ for (const model of models) {
+ if (model.uri.scheme === ctx.doc.URI_SCHEME && !uris.includes(model.uri.toString())) {
+ logger.debug('dispose model', model.uri.toString())
+ model.dispose()
+ }
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-words.ts b/src/renderer/plugins/editor-words.ts
new file mode 100644
index 000000000..5f48cf037
--- /dev/null
+++ b/src/renderer/plugins/editor-words.ts
@@ -0,0 +1,80 @@
+import type * as Monaco from 'monaco-editor'
+import type { Ctx, Plugin } from '@fe/context'
+
+function getWords (content: string) {
+ const words = new Set()
+
+ if (content.length > 102400) {
+ return words
+ }
+
+ const identifier = /[a-zA-Z_]+\w/g
+
+ while (true) {
+ if (words.size > 1000) {
+ break
+ }
+
+ const res = identifier.exec(content)
+ if (!res) {
+ break
+ }
+
+ if (res[0].length > 2 && res[0].length < 15) {
+ words.add(res[0])
+ }
+ }
+
+ return words
+}
+
+class WordsCompletionProvider implements Monaco.languages.CompletionItemProvider {
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ public async provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Promise {
+ const selection = this.ctx.editor.getEditor().getSelection()
+ if (!selection?.isEmpty()) { // only trigger when no selection
+ return
+ }
+
+ const currentWord = model.getWordUntilPosition(position)
+ const result: Monaco.languages.CompletionItem[] = []
+
+ getWords(model.getValue()).forEach((word, i) => {
+ if (currentWord.word !== word) {
+ result.push({
+ label: { label: word },
+ kind: this.monaco.languages.CompletionItemKind.Text,
+ insertText: word,
+ range: new this.monaco.Range(
+ position.lineNumber,
+ currentWord.startColumn,
+ position.lineNumber,
+ currentWord.endColumn,
+ ),
+ sortText: i.toString().padStart(7)
+ })
+ }
+ })
+
+ return { suggestions: result }
+ }
+}
+
+export default {
+ name: 'editor-words',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new WordsCompletionProvider(monaco, ctx)
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/electron-zoom.ts b/src/renderer/plugins/electron-zoom.ts
new file mode 100644
index 000000000..44facc1b5
--- /dev/null
+++ b/src/renderer/plugins/electron-zoom.ts
@@ -0,0 +1,88 @@
+import type { Plugin } from '@fe/context'
+import type { BuildInActionName } from '@fe/types'
+
+export default {
+ name: 'electron-zoom',
+ register: (ctx) => {
+ if (!ctx.env.isElectron) {
+ return
+ }
+
+ ctx.registerHook('STARTUP', () => {
+ const webContents = ctx.env.getElectronRemote().getCurrentWebContents()
+
+ function setZoomFactor (factor: number) {
+ webContents.setZoomFactor(factor)
+ ctx.statusBar.refreshMenu()
+ }
+
+ function changeZoomFactor (zoomIn: boolean) {
+ const currentZoomFactor = webContents.getZoomFactor()
+ const factor = currentZoomFactor + (zoomIn ? 0.1 : -0.1)
+
+ if (factor > 0.2 && factor < 2) {
+ setZoomFactor(factor)
+ }
+ }
+
+ const zoomInId: BuildInActionName = 'plugin.electron-zoom.zoom-in'
+ const zoomOutId: BuildInActionName = 'plugin.electron-zoom.zoom-out'
+ const zoomResetId: BuildInActionName = 'plugin.electron-zoom.zoom-reset'
+
+ ctx.action.registerAction({
+ name: zoomInId,
+ keys: [ctx.keybinding.CtrlCmd, '='],
+ description: ctx.i18n.t('command-desc.plugin_electron-zoom_zoom-in'),
+ forUser: true,
+ handler: () => changeZoomFactor(true)
+ })
+
+ ctx.action.registerAction({
+ name: zoomOutId,
+ keys: [ctx.keybinding.CtrlCmd, '-'],
+ description: ctx.i18n.t('command-desc.plugin_electron-zoom_zoom-out'),
+ forUser: true,
+ handler: () => changeZoomFactor(false)
+ })
+
+ ctx.action.registerAction({
+ name: zoomResetId,
+ keys: [ctx.keybinding.CtrlCmd, '0'],
+ description: ctx.i18n.t('command-desc.plugin_electron-zoom_zoom-reset'),
+ forUser: true,
+ handler: () => setZoomFactor(1)
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ const factor = ctx.env.getElectronRemote().getCurrentWebContents().getZoomFactor()
+ menus['status-bar-view']?.list?.push(
+ { type: 'separator' },
+ {
+ id: zoomInId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('electron-zoom.zoom-in'),
+ disabled: factor >= 1.9,
+ subTitle: ctx.keybinding.getKeysLabel(zoomInId),
+ onClick: () => ctx.action.getActionHandler(zoomInId)()
+ },
+ {
+ id: zoomOutId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('electron-zoom.zoom-out'),
+ disabled: factor < 0.25,
+ subTitle: ctx.keybinding.getKeysLabel(zoomOutId),
+ onClick: () => ctx.action.getActionHandler(zoomOutId)()
+ },
+ {
+ id: zoomResetId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('electron-zoom.zoom-reset'),
+ disabled: factor === 1,
+ subTitle: ctx.keybinding.getKeysLabel(zoomResetId),
+ onClick: () => ctx.action.getActionHandler(zoomResetId)()
+ },
+ )
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/emoji.ts b/src/renderer/plugins/emoji.ts
new file mode 100644
index 000000000..8bc9ce371
--- /dev/null
+++ b/src/renderer/plugins/emoji.ts
@@ -0,0 +1,110 @@
+import type * as Monaco from 'monaco-editor'
+import MarkdownItEmoji from 'markdown-it-emoji/dist/full.cjs.js'
+import emoji from 'markdown-it-emoji/lib/data/full.mjs'
+import type { Ctx, Plugin } from '@fe/context'
+
+const triggerCharacter = ':'
+
+class EmojiCompletionProvider implements Monaco.languages.CompletionItemProvider {
+ public readonly triggerCharacters = [triggerCharacter]
+
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ public provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Monaco.languages.CompletionList {
+ if (!this.ctx.setting.getSetting('editor.complete-emoji')) {
+ return { suggestions: [] }
+ }
+
+ const line = model.getLineContent(position.lineNumber)
+ const cursor = position.column - 1
+ const linePrefixText = line.slice(0, cursor)
+
+ // check language id
+ if (this.ctx.editor.getLineLanguageId(position.lineNumber, model) !== 'markdown') {
+ return { suggestions: [] }
+ }
+
+ // Check if the cursor is in a wiki link
+ if (linePrefixText.lastIndexOf('[[') > linePrefixText.lastIndexOf(']]')) {
+ return { suggestions: [] }
+ }
+
+ const match = linePrefixText.match(/:[a-zA-Z0-9]*$/)
+ if (!match || linePrefixText.charAt(linePrefixText.length - match[0].length - 1) === ':') {
+ return { suggestions: [] }
+ }
+
+ const startPos = position.delta(0, -match[0].length)
+
+ const result: Monaco.languages.CompletionItem[] = []
+ Object.keys(emoji).forEach((key, i) => {
+ result.push({
+ label: { label: `:${key}:${(emoji as any)[key]}` },
+ kind: this.monaco.languages.CompletionItemKind.EnumMember,
+ insertText: (emoji as any)[key],
+ range: new this.monaco.Range(
+ position.lineNumber,
+ startPos.column,
+ position.lineNumber,
+ position.column
+ ),
+ sortText: i.toString().padStart(7),
+ })
+ })
+
+ return { suggestions: result }
+ }
+}
+
+export default {
+ name: 'editor-emoji',
+ register: (ctx) => {
+ ctx.markdown.registerPlugin(md => {
+ md.use(MarkdownItEmoji)
+
+ md.renderer.rules.emoji = (token, idx) => {
+ return ctx.lib.vue.createVNode(ctx.lib.vue.Text, null, token[idx].content) as any
+ }
+ })
+
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new EmojiCompletionProvider(monaco, ctx)
+ )
+ })
+
+ ctx.setting.changeSchema(schema => {
+ schema.properties['render.md-emoji'] = {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-emoji',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ }
+ schema.properties['editor.complete-emoji'] = {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.complete-emoji',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ }
+ })
+
+ ctx.registerHook('MARKDOWN_BEFORE_RENDER', ({ md }) => {
+ if (ctx.setting.getSetting('render.md-emoji')) {
+ md.enable('emoji', true)
+ } else {
+ md.disable('emoji', true)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/file-tree-functions.ts b/src/renderer/plugins/file-tree-functions.ts
new file mode 100644
index 000000000..247376a47
--- /dev/null
+++ b/src/renderer/plugins/file-tree-functions.ts
@@ -0,0 +1,143 @@
+import { Plugin, Ctx } from '@fe/context'
+import { isNormalRepo } from '@fe/services/repo'
+import { FLAG_DISABLE_XTERM } from '@fe/support/args'
+import type { Components, Doc } from '@fe/types'
+
+export default {
+ name: 'file-tree-context-menu',
+ register: (ctx: Ctx) => {
+ function revealInXterminal (node: Doc) {
+ const { currentRepo } = ctx.store.state
+ const path = currentRepo ? ctx.utils.path.join(currentRepo.path, node.path) : ''
+ if (path) {
+ ctx.action.getActionHandler('xterm.run')(`--yank-note-run-command-cd-- ${path}`)
+ }
+ }
+
+ function addItem (node: Doc) {
+ const input = window.document.createElement('input')
+ input.type = 'file'
+ input.multiple = true
+ input.onchange = async () => {
+ for (let i = 0; i < input.files!.length; i++) {
+ const file = input.files![i]
+ const fileBase64Url = await ctx.utils.fileToBase64URL(file)
+ const filePath = ctx.utils.path.resolve(node.path, file.name)
+ await ctx.api.upload(node.repo, fileBase64Url, filePath)
+ }
+
+ ctx.tree.refreshTree()
+ }
+ input.click()
+ }
+
+ function getItems (node: Components.Tree.Node, position: 'tabs' | 'tree'): Components.ContextMenu.Item[] {
+ const t = ctx.i18n.t
+
+ const disableItems = ctx.args.FLAG_READONLY
+ ? ['add-item', 'duplicate', 'duplicate', 'create-dir', 'create-doc', 'create-in-cd', 'rename', 'delete', 'open-in-terminal']
+ : []
+
+ if (position === 'tabs') {
+ disableItems.push('refresh')
+ }
+
+ return [
+ ...(node.type === 'dir' ? [
+ { id: 'create-doc', label: t('tree.context-menu.create-doc'), onClick: () => ctx.doc.createDoc({ repo: node.repo }, node), ellipsis: true },
+ { id: 'create-dir', label: t('tree.context-menu.create-dir'), onClick: () => ctx.doc.createDir({ repo: node.repo }, node), ellipsis: true },
+ { id: 'add-item', label: t('tree.context-menu.add-item'), onClick: () => addItem(node), ellipsis: true },
+ ] : []),
+ ...(node.path !== '/' ? [
+ { id: 'rename', label: t('tree.context-menu.rename'), onClick: () => ctx.doc.moveDoc(node), ellipsis: true },
+ { id: 'delete', label: t('tree.context-menu.delete'), onClick: () => ctx.doc.deleteDoc(node), ellipsis: true },
+ ] : []),
+ ...(!ctx.doc.isEncrypted(node) ? [
+ { id: 'duplicate', label: t('tree.context-menu.duplicate'), onClick: () => ctx.doc.duplicateDoc(node), ellipsis: true },
+ ] : []),
+ { type: 'separator' },
+ { id: 'open-in-os', label: t('tree.context-menu.open-in-os'), onClick: () => ctx.doc.openInOS(node) },
+ ...(node.type === 'file' ? [
+ { id: 'reveal-in-os', label: t('tree.context-menu.reveal-in-os'), onClick: () => ctx.doc.openInOS(node, true) }
+ ] : []),
+ { id: 'refresh', label: t('tree.context-menu.refresh'), onClick: () => ctx.tree.refreshTree() },
+ ...(node.type === 'dir' ? [
+ { id: 'find-in-folder', label: t('tree.context-menu.find-in-folder'), onClick: () => ctx.base.findInRepository({ include: node.path.replace(/^\//, '') + '/**/*.md' }), ellipsis: true },
+ ] : []),
+ ...(node.type === 'dir' && !FLAG_DISABLE_XTERM ? [
+ { id: 'open-in-terminal', label: t('tree.context-menu.open-in-terminal'), onClick: () => revealInXterminal(node) },
+ ] : []),
+ { id: 'create-in-cd', label: t('tree.context-menu.create-in-cd'), onClick: () => ctx.doc.createDoc({ repo: node.repo }, node), ellipsis: true },
+ { type: 'separator' },
+ { id: 'copy-name', label: t('tree.context-menu.copy-name'), onClick: () => ctx.utils.copyText(node.name) },
+ { id: 'copy-path', label: t('tree.context-menu.copy-path'), onClick: () => ctx.utils.copyText(node.path) }
+ ].filter((x: any) => (!x.id || !disableItems.includes(x.id))) as Components.ContextMenu.Item[]
+ }
+
+ ctx.tree.tapContextMenus((items, node, vueCtx) => {
+ async function toggleMark () {
+ if ((node as any).marked) {
+ vueCtx.localMarked.value = false
+ await ctx.doc.unmarkDoc(node)
+ } else {
+ vueCtx.localMarked.value = true
+ await ctx.doc.markDoc(node)
+ }
+
+ node.marked = vueCtx.localMarked.value
+ }
+
+ const t = ctx.i18n.t
+
+ items.push(...[
+ ...(ctx.doc.supported(node) ? [
+ {
+ id: 'mark',
+ label: node.marked ? t('tree.context-menu.unmark') : t('tree.context-menu.mark'),
+ onClick: () => toggleMark()
+ },
+ ] : []),
+ ...getItems(node, 'tree')
+ ])
+ })
+
+ ctx.workbench.FileTabs.tapTabContextMenus((items, tab) => {
+ const doc: Doc | null = tab.payload.file
+
+ if (!doc || doc.type !== 'file' || !isNormalRepo(doc.repo)) {
+ return
+ }
+
+ items.push(...getItems(doc as Components.Tree.Node, 'tabs'))
+ })
+
+ async function createFile (node: Components.Tree.Node) {
+ await ctx.doc.createDoc({ repo: node.repo }, node)
+ }
+
+ async function createFolder (node: Components.Tree.Node) {
+ await ctx.doc.createDir({ repo: node.repo }, node)
+ }
+
+ ctx.tree.tapNodeActionButtons((btns, node) => {
+ if (ctx.args.FLAG_READONLY || node.type !== 'dir') {
+ return
+ }
+
+ btns.push(
+ {
+ id: 'create-folder',
+ title: ctx.i18n.t('tree.context-menu.create-dir'),
+ icon: 'folder-plus-solid',
+ onClick: () => createFolder(node)
+ },
+ {
+ id: 'create-file',
+ title: ctx.i18n.t('tree.context-menu.create-doc'),
+ icon: 'plus',
+ onClick: () => createFile(node)
+ }
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/get-started/GetStarted.vue b/src/renderer/plugins/get-started/GetStarted.vue
new file mode 100644
index 000000000..7187f9d70
--- /dev/null
+++ b/src/renderer/plugins/get-started/GetStarted.vue
@@ -0,0 +1,225 @@
+
+
+
+
+ {{$t('app-name')}}
+ {{$t('slogan')}}
+
+
+
+ {{$t('get-started.start')}}
+
+
+
+ {{$t('get-started.help')}}
+
+
+
+ {{$t('get-started.recent')}}
+
+
+ {{item.node.name}}
+
+ {{dayjs(item.time).fromNow()}}
+
+
+
+ {{$t('more')}}…
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/plugins/get-started/index.ts b/src/renderer/plugins/get-started/index.ts
new file mode 100644
index 000000000..b08cac65f
--- /dev/null
+++ b/src/renderer/plugins/get-started/index.ts
@@ -0,0 +1,17 @@
+import type { Plugin } from '@fe/context'
+import GetStarted from './GetStarted.vue'
+
+export default {
+ name: 'get-started',
+ register: (ctx) => {
+ ctx.editor.registerCustomEditor({
+ name: 'get-started',
+ displayName: 'Get Started',
+ hiddenPreview: true,
+ when ({ doc }) {
+ return doc === null && ctx.args.MODE === 'normal'
+ },
+ component: GetStarted,
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/history-stack.ts b/src/renderer/plugins/history-stack.ts
new file mode 100644
index 000000000..9f7eeb47c
--- /dev/null
+++ b/src/renderer/plugins/history-stack.ts
@@ -0,0 +1,202 @@
+import type { Plugin, Ctx } from '@fe/context'
+import type { Doc, PathItem, PositionState } from '@fe/types'
+
+type State = { doc: Doc, position?: PositionState | null}
+
+export default {
+ name: 'history-stack',
+ register: (ctx: Ctx) => {
+ const maxLength = 100
+ let stack: State[] = []
+ let idx = -1
+ const logger = ctx.utils.getLogger('plugin:history-stack')
+
+ const backId = 'plugin.document-history-stack.back'
+ const forwardId = 'plugin.document-history-stack.forward'
+
+ function refresh () {
+ ctx.workbench.ControlCenter.refresh()
+ ctx.statusBar.refreshMenu()
+
+ logger.debug('refresh', stack, idx, stack[idx])
+ }
+
+ function go (offset: number) {
+ const index = idx + offset
+ if (index >= stack.length || index < 0) {
+ return
+ }
+
+ const nextState = stack[index]
+
+ ctx.doc.switchDoc(nextState.doc, { source: 'history-stack', position: nextState.position }).then(() => {
+ idx = index
+ refresh()
+ })
+ }
+
+ function removeFromStack (doc?: PathItem) {
+ stack = stack.filter(x => !ctx.doc.isSubOrSameFile(doc, x.doc))
+ if (idx >= stack.length) {
+ idx = stack.length - 1
+ }
+
+ refresh()
+ }
+
+ function record (doc: Doc, position: PositionState | null) {
+ const newState: State = { doc: { type: doc.type, repo: doc.repo, name: doc.name, path: doc.path }, position }
+
+ // check same doc
+ if (stack[idx] && ctx.doc.isSameFile(doc, stack[idx].doc)) {
+ if (position) {
+ // check same position
+ if (ctx.lib.lodash.isEqual(position, stack[idx].position)) {
+ return
+ }
+ } else {
+ // not special position, check if already has position
+ if (isScrollPosition(stack[idx].position)) {
+ return
+ }
+ }
+ }
+
+ stack.splice(idx + 1, stack.length)
+ stack.push(newState)
+ idx = stack.length - 1
+
+ if (stack.length > maxLength) {
+ stack = stack.slice(stack.length - maxLength)
+ }
+
+ refresh()
+ }
+
+ function isScrollPosition (position: PositionState | undefined | null) {
+ return position && ('editorScrollTop' in position || 'viewScrollTop' in position)
+ }
+
+ function savePosition () {
+ const currentState = stack[idx]
+ const currentDoc = ctx.store.state.currentFile
+ if (!currentState || !currentDoc) {
+ return
+ }
+
+ // update scroll position when switching doc
+ if ((!currentState.position || isScrollPosition(currentState.position)) && ctx.doc.isSubOrSameFile(currentDoc, currentState.doc)) {
+ const viewScrollTop = ctx.view.getScrollTop() || 0
+ const editorScrollTop = ctx.editor.getEditor()?.getScrollTop() || 0
+ currentState.position = { viewScrollTop, editorScrollTop }
+ }
+ }
+
+ ctx.registerHook('DOC_PRE_SWITCH', () => {
+ savePosition()
+ })
+
+ ctx.registerHook('DOC_SWITCHED', ({ doc, opts }) => {
+ // do not record position when switching doc by history stack
+ if (opts?.source === 'history-stack') {
+ return
+ }
+
+ if (!doc && !opts?.position) {
+ return
+ }
+
+ const _doc = doc || ctx.store.state.currentFile
+ if (!_doc) {
+ return
+ }
+
+ const position = opts?.position || (stack as any).findLast((x: State) => {
+ return isScrollPosition(x.position) && ctx.doc.isSubOrSameFile(_doc, x.doc)
+ })?.position
+
+ if (!opts?.position && position) {
+ ctx.routines.changePosition(position)
+ }
+
+ record(_doc, null) // do not record cross doc position
+ })
+
+ ctx.registerHook('DOC_SWITCH_SKIPPED', ({ doc, opts }) => {
+ if (opts?.source === 'history-stack') {
+ return
+ }
+
+ // record in page navigation
+ if (doc && opts?.position) {
+ record(doc, opts?.position)
+ }
+ })
+
+ ctx.registerHook('DOC_DELETED', ({ doc }) => removeFromStack(doc))
+ ctx.registerHook('DOC_MOVED', ({ oldDoc }) => removeFromStack(oldDoc))
+ ctx.registerHook('DOC_SWITCH_FAILED', ({ doc }) => { doc && removeFromStack(doc) })
+
+ ctx.action.registerAction({
+ name: backId,
+ description: ctx.i18n.t('command-desc.plugin_document-history-stack_back'),
+ forUser: true,
+ handler: () => go(-1),
+ keys: [ctx.keybinding.Alt, ctx.keybinding.BracketLeft],
+ })
+
+ ctx.action.registerAction({
+ name: forwardId,
+ description: ctx.i18n.t('command-desc.plugin_document-history-stack_forward'),
+ forUser: true,
+ handler: () => go(1),
+ keys: [ctx.keybinding.Alt, ctx.keybinding.BracketRight],
+ })
+
+ ctx.registerHook('STARTUP', () => {
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-navigation']?.list?.push(
+ {
+ id: forwardId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('status-bar.nav.forward'),
+ disabled: idx >= stack.length - 1,
+ subTitle: ctx.keybinding.getKeysLabel(forwardId),
+ onClick: () => ctx.action.getActionHandler(forwardId)()
+ },
+ {
+ id: backId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('status-bar.nav.back'),
+ disabled: idx <= 0,
+ subTitle: ctx.keybinding.getKeysLabel(backId),
+ onClick: () => ctx.action.getActionHandler(backId)()
+ },
+ )
+ })
+ })
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.navigation.items.push(
+ {
+ type: 'btn',
+ icon: 'arrow-left-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.back', ctx.keybinding.getKeysLabel(backId)),
+ disabled: idx <= 0,
+ showInActionBar: true,
+ onClick: () => ctx.action.getActionHandler(backId)()
+ },
+ {
+ type: 'btn',
+ icon: 'arrow-right-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.forward', ctx.keybinding.getKeysLabel(forwardId)),
+ disabled: idx >= stack.length - 1,
+ showInActionBar: true,
+ onClick: () => ctx.action.getActionHandler(forwardId)()
+ },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/image-hosting-picgo.ts b/src/renderer/plugins/image-hosting-picgo.ts
new file mode 100644
index 000000000..bd1a9d403
--- /dev/null
+++ b/src/renderer/plugins/image-hosting-picgo.ts
@@ -0,0 +1,278 @@
+import type Token from 'markdown-it/lib/token'
+import { Plugin, Ctx } from '@fe/context'
+import { DOM_ATTR_NAME, FLAG_DEMO } from '@fe/support/args'
+
+export default {
+ name: 'image-hosting-picgo',
+ register: (ctx: Ctx) => {
+ const logger = ctx.utils.getLogger('plugin.image-hosting-picgo')
+ const uploadActionName = 'plugin.image-hosting-picgo.upload'
+ const settingKeyUrl = 'plugin.image-hosting-picgo.server-url'
+ const settingKeyPaste = 'plugin.image-hosting-picgo.enable-paste-image'
+
+ ctx.setting.changeSchema((schema) => {
+ schema.properties[settingKeyUrl] = {
+ title: 'T_picgo.setting.api-title',
+ description: 'T_picgo.setting.api-desc',
+ type: 'string',
+ defaultValue: 'http://127.0.0.1:36677/upload',
+ pattern: '^(http://|https://|$)',
+ options: {
+ patternmessage: 'T_picgo.setting.api-msg',
+ },
+ group: 'image',
+ }
+
+ schema.properties[settingKeyPaste] = {
+ title: 'T_picgo.setting.paste-title',
+ type: 'boolean',
+ format: 'checkbox',
+ defaultValue: false,
+ group: 'image',
+ }
+ })
+
+ ctx.action.registerAction({
+ name: uploadActionName,
+ handler: async (file: File) => {
+ if (FLAG_DEMO) {
+ ctx.ui.useToast().show('warning', ctx.i18n.t('demo-tips'))
+ return URL.createObjectURL(file)
+ }
+
+ const url = ctx.setting.getSettings()[settingKeyUrl]
+
+ if (!url) {
+ const msg = ctx.i18n.t('picgo.need-api')
+ ctx.ui.useToast().show('warning', msg)
+ ctx.setting.showSettingPanel()
+ throw new Error(msg)
+ }
+
+ ctx.ui.useToast().show('info', ctx.i18n.t('picgo.uploading'), 0)
+
+ logger.debug('upload', url, file)
+
+ // remote mode, use multipart/form-data to upload
+ if (url.includes('key=')) {
+ const formData = new FormData()
+ formData.append('file', file)
+
+ try {
+ const { result } = await ctx.api.proxyFetch(
+ url,
+ { method: 'post', body: formData, },
+ ).then(r => r.json())
+
+ ctx.ui.useToast().hide()
+
+ if (result.length > 0) {
+ return result[0]
+ }
+ } catch (error) {
+ const msg = ctx.i18n.t('picgo.upload-failed')
+ ctx.ui.useToast().show('warning', msg)
+ throw new Error(msg)
+ }
+
+ return
+ }
+
+ const tmpFileName = 'picgo-' + file.name
+
+ try {
+ const { data: { path } } = await ctx.api.writeTmpFile(tmpFileName, await ctx.utils.fileToBase64URL(file), true)
+ logger.debug('tmp file', path)
+
+ const { result } = await ctx.api.proxyFetch(
+ url,
+ {
+ method: 'post',
+ body: { list: [path] },
+ jsonBody: true,
+ },
+ ).then(r => r.json())
+
+ ctx.ui.useToast().hide()
+
+ if (result.length > 0) {
+ return result[0]
+ }
+ } catch (error) {
+ const msg = ctx.i18n.t('picgo.upload-failed')
+ ctx.ui.useToast().show('warning', msg)
+ throw new Error(msg)
+ } finally {
+ ctx.api.deleteTmpFile(tmpFileName)
+ }
+ }
+ })
+
+ ctx.registerHook('EDITOR_PASTE_IMAGE', async ({ file }) => {
+ if (!ctx.setting.getSettings()[settingKeyPaste]) {
+ return false
+ }
+
+ await insertImage(file)
+
+ return true
+ })
+
+ async function insertImage (file: File) {
+ if (!ctx.store.state.currentFile) {
+ throw new Error('No file opened.')
+ }
+ const url = await ctx.action.getActionHandler(uploadActionName)(file)
+ ctx.editor.insert(`\n`)
+ }
+
+ function addImage () {
+ const input = window.document.createElement('input')
+ input.type = 'file'
+ input.multiple = true
+ input.onchange = async () => {
+ for (let i = 0; i < input.files!.length; i++) {
+ await insertImage(input.files![i])
+ }
+ }
+ input.click()
+ }
+
+ async function uploadLocalImage (srcAttr: string, originSrc: string) {
+ if (srcAttr && originSrc) {
+ const res: Response = await ctx.api.fetchHttp(srcAttr)
+ const fileName = ctx.utils.path.basename(ctx.utils.removeQuery(originSrc))
+ const file = new File(
+ [await res.blob()],
+ fileName,
+ { type: ctx.lib.mime.getType(fileName) || undefined }
+ )
+
+ try {
+ return await ctx.action.getActionHandler('plugin.image-hosting-picgo.upload')(file)
+ } catch (error) {
+ return null
+ }
+ }
+ }
+
+ async function uploadAllImage () {
+ const tokens = ctx.view.getRenderEnv()?.tokens
+ if (!tokens) {
+ return
+ }
+
+ const currentDocChecker = ctx.doc.createCurrentDocChecker()
+
+ const processImg = async (tokens: Token[]) => {
+ for (const token of tokens) {
+ currentDocChecker.throwErrorIfChanged()
+
+ if (token.children) {
+ await processImg(token.children)
+ }
+
+ if (token.tag === 'img' && token.attrGet(ctx.args.DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ const srcAttr = token.attrGet('src')
+ const originSrc = token.attrGet(ctx.args.DOM_ATTR_NAME.ORIGIN_SRC)
+ const url = await uploadLocalImage(srcAttr!, originSrc!)
+
+ currentDocChecker.throwErrorIfChanged()
+
+ if (url) {
+ ctx.editor.replaceValue(
+ ctx.utils.encodeMarkdownLink(originSrc!),
+ ctx.utils.encodeMarkdownLink(url)
+ )
+ }
+ }
+ }
+ }
+
+ await processImg(tokens)
+ }
+
+ function when () {
+ const currentFile = ctx.store.state.currentFile
+ const previewFile = ctx.view.getRenderEnv()?.file
+
+ return !!(currentFile && ctx.editor.isDefault() && ctx.doc.isSameFile(currentFile, previewFile))
+ }
+
+ const addImageActionId = 'plugin.image-hosting-picgo.add-image'
+ const uploadAllImageActionId = 'plugin.image-hosting-picgo.upload-all-image'
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.addAction({
+ id: addImageActionId,
+ contextMenuGroupId: 'modification',
+ label: ctx.i18n.t('add-image') + ' (PicGo)',
+ run: addImage,
+ })
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ if (!when()) return
+
+ menus['status-bar-insert']?.list?.unshift({
+ id: addImageActionId,
+ type: 'normal',
+ title: ctx.i18n.t('add-image'),
+ ellipsis: true,
+ subTitle: 'PicGo',
+ onClick: addImage
+ })
+
+ menus['status-bar-tool']?.list?.push({
+ id: uploadAllImageActionId,
+ type: 'normal',
+ title: ctx.i18n.t('picgo.upload-all-images'),
+ subTitle: 'PicGo',
+ onClick: uploadAllImage
+ })
+ })
+
+ ctx.view.tapContextMenus((items, e) => {
+ if (!when()) return
+
+ const el = e.target as HTMLElement
+
+ if (
+ el.tagName === 'IMG' &&
+ el.getAttribute(DOM_ATTR_NAME.LOCAL_IMAGE)
+ ) {
+ const repo = el.getAttribute(DOM_ATTR_NAME.TARGET_REPO)
+ if (repo === ctx.args.HELP_REPO_NAME) {
+ return
+ }
+
+ items.push({
+ id: 'plugin.image-hosting-picgo.upload-single-image',
+ type: 'normal',
+ ellipsis: false,
+ label: ctx.i18n.t('upload-image') + ' (PicGo)',
+ onClick: async () => {
+ try {
+ if (!ctx.store.state.currentFile) {
+ throw new Error('No file opened.')
+ }
+
+ const srcAttr = el.getAttribute('src')
+ const originSrc = el.getAttribute(DOM_ATTR_NAME.ORIGIN_SRC)!
+
+ const url = await uploadLocalImage(srcAttr!, originSrc)
+ if (url) {
+ ctx.editor.replaceValue(
+ ctx.utils.encodeMarkdownLink(originSrc),
+ ctx.utils.encodeMarkdownLink(url)
+ )
+ }
+ } catch (error: any) {
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ })
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/image-localization.ts b/src/renderer/plugins/image-localization.ts
new file mode 100644
index 000000000..efc324939
--- /dev/null
+++ b/src/renderer/plugins/image-localization.ts
@@ -0,0 +1,156 @@
+import mime from 'mime'
+import * as api from '@fe/support/api'
+import { encodeMarkdownLink, removeQuery } from '@fe/utils'
+import { useToast } from '@fe/support/ui/toast'
+import store from '@fe/support/store'
+import { replaceValue } from '@fe/services/editor'
+import { refreshTree } from '@fe/services/tree'
+import { upload } from '@fe/services/base'
+import { getViewDom } from '@fe/services/view'
+import type { Plugin } from '@fe/context'
+import type { BuildInActionName } from '@fe/types'
+
+async function transformImgOutLink (img: HTMLImageElement) {
+ const { currentFile } = store.state
+ if (!currentFile) {
+ return
+ }
+
+ const transform = (ximg: HTMLImageElement): Promise => {
+ const canvas = document.createElement('canvas')
+ canvas.width = ximg.naturalWidth
+ canvas.height = ximg.naturalHeight
+ canvas.getContext('2d')!.drawImage(ximg, 0, 0)
+ return new Promise((resolve, reject) => {
+ canvas.toBlob(async blob => {
+ try {
+ const imgFile = new File([blob!], 'file.png')
+ const assetPath = await upload(imgFile, currentFile)
+ resolve(assetPath)
+ } catch (error) {
+ reject(error)
+ }
+ })
+ })
+ }
+
+ let replacedLink = ''
+ const imgAttrSrc = img.getAttribute('src') || ''
+ if (img.src.startsWith('data:')) {
+ replacedLink = await transform(img)
+ } else if (imgAttrSrc.startsWith('http://') || imgAttrSrc.startsWith('https://')) {
+ const headers = JSON.parse(img.getAttribute('headers') || '{}')
+ const res = await api.proxyFetch(img.src, { headers })
+ const blob = await res.blob()
+ const contentType = res.headers.get('content-type') || ''
+
+ if (!contentType.startsWith('image/')) {
+ throw new Error('Not an image')
+ }
+
+ const ext = mime.getExtension(contentType) || ''
+ const imgFile = new File([blob!], 'file.' + ext)
+ const name = removeQuery(img.src).split('/').pop() // get file name from url
+ const assetPath = await upload(
+ imgFile,
+ currentFile,
+ ext === name?.split('.').pop() ? name : undefined // if ext is not same as file name, use file name
+ )
+ replacedLink = assetPath
+ }
+
+ if (replacedLink) {
+ return { oldLink: img.src, replacedLink: encodeMarkdownLink(replacedLink) }
+ }
+
+ return null
+}
+
+const actionKeydown: BuildInActionName = 'plugin.image-localization.download-all'
+const commandClick = 'plugin.image-localization.single-by-click'
+
+async function transformAll () {
+ const refView = getViewDom()
+ if (!refView) {
+ return
+ }
+
+ const toast = useToast()
+
+ const result = []
+ const imgList = refView.querySelectorAll('img')
+ for (let i = 0; i < imgList.length; i++) {
+ toast.show('info', `${i + 1}/${imgList.length}`)
+
+ const img = imgList[i]
+ const data = await transformImgOutLink(img)
+ if (data) {
+ result.push(data)
+ }
+ }
+ result.forEach(data => replaceValue(data.oldLink, data.replacedLink))
+ refreshTree()
+}
+
+export default {
+ name: 'image-localization',
+ register: (ctx) => {
+ function when () {
+ const currentFile = ctx.store.state.currentFile
+ const previewFile = ctx.view.getRenderEnv()?.file
+
+ return !!(currentFile && ctx.editor.isDefault() && ctx.doc.isSameFile(currentFile, previewFile))
+ }
+
+ ctx.action.registerAction({
+ name: actionKeydown,
+ handler: transformAll,
+ description: ctx.i18n.t('command-desc.plugin_image-localization_all'),
+ forUser: true,
+ when,
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ if (!when()) return
+
+ menus['status-bar-tool']?.list?.push(
+ {
+ id: actionKeydown,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.tool.convert-img-link'),
+ onClick: ctx.action.getActionHandler(actionKeydown)
+ },
+ )
+ })
+
+ ctx.view.tapContextMenus((items, e) => {
+ if (!when()) return
+
+ const el = e.target as HTMLElement
+
+ if (
+ el.tagName === 'IMG' &&
+ /^https:\/\/|^http:\/\/|^data:/.test(el.getAttribute('src') || '')
+ ) {
+ items.push({
+ id: commandClick,
+ type: 'normal',
+ label: ctx.i18n.t('status-bar.tool.convert-img-link'),
+ onClick: async () => {
+ try {
+ ctx.ui.useToast().show('info', 'Loading……', 0)
+ const data = await transformImgOutLink(el as HTMLImageElement)
+ if (data) {
+ replaceValue(data.oldLink, data.replacedLink)
+ refreshTree()
+ }
+ ctx.ui.useToast().hide()
+ } catch (error: any) {
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ })
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/image-viewer.ts b/src/renderer/plugins/image-viewer.ts
deleted file mode 100644
index 1af14d57d..000000000
--- a/src/renderer/plugins/image-viewer.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { debounce } from 'lodash-es'
-import Viewer from 'viewerjs'
-import type { Plugin } from '@fe/context/plugin'
-import 'viewerjs/dist/viewer.css'
-
-let viewer: any
-
-export default {
- name: 'image-viewer',
- register: ctx => {
- ctx.registerHook('ON_VIEW_RENDERED', debounce(({ getViewDom }) => {
- if (!viewer) {
- viewer = new Viewer(getViewDom(), { zIndex: 299999 })
- }
-
- viewer.update()
- }, 500))
-
- ctx.theme.addStyles(`
- body .viewer-backdrop,
- body .viewer-navbar {
- background: rgba(167, 167, 167, 0.6);
- }
- `)
- }
-} as Plugin
diff --git a/src/renderer/plugins/image-viewer.tsx b/src/renderer/plugins/image-viewer.tsx
new file mode 100644
index 000000000..91dbfbb18
--- /dev/null
+++ b/src/renderer/plugins/image-viewer.tsx
@@ -0,0 +1,173 @@
+import { defineComponent, onBeforeUnmount, onMounted, ref, watchEffect } from 'vue'
+import mime from 'mime'
+import { debounce } from 'lodash-es'
+import Viewer from 'viewerjs'
+import type { Plugin } from '@fe/context'
+import store from '@fe/support/store'
+import { getAttachmentURL } from '@fe/services/base'
+import { sleep } from '@fe/utils'
+import type { Doc } from '@fe/types'
+
+import 'viewerjs/dist/viewer.css'
+
+function isImageFile (doc?: Doc | null) {
+ if (!doc) {
+ return false
+ }
+
+ if (doc.name.toLowerCase().endsWith('.svg')) {
+ return true
+ }
+
+ if (doc.plain) {
+ return false
+ }
+
+ const fileMime = mime.getType(doc.name)
+ return !!fileMime && fileMime.startsWith('image/')
+}
+
+const ImageViewer = defineComponent({
+ setup () {
+ const img = ref()
+ let viewer: Viewer | null = null
+
+ function clean () {
+ if (viewer) {
+ viewer.destroy()
+ viewer = null
+ }
+ }
+
+ onMounted(() => {
+ watchEffect(async () => {
+ const doc = store.state.currentFile
+ if (doc && img.value && isImageFile(doc)) {
+ clean()
+ await sleep(0)
+ viewer = new Viewer(img.value, {
+ inline: true,
+ navbar: false,
+ fullscreen: false,
+ button: false,
+ backdrop: false,
+ transition: false,
+ toolbar: {
+ zoomIn: true,
+ zoomOut: true,
+ flipHorizontal: true,
+ flipVertical: true,
+ oneToOne: true,
+ reset: true,
+ rotateLeft: true,
+ rotateRight: true,
+ },
+ url () {
+ return getAttachmentURL(doc)
+ },
+ })
+
+ await sleep(0)
+ }
+ })
+ })
+
+ onBeforeUnmount(clean)
+
+ return () => ![]()
+ }
+})
+
+export default {
+ name: 'image-viewer',
+ register: ctx => {
+ ctx.registerHook('VIEW_MOUNTED', () => {
+ setTimeout(() => {
+ const viewer = new Viewer(ctx.view.getViewDom()!, {
+ zIndex: 2.11e8,
+ container: document.body,
+ transition: false,
+ toolbar: {
+ zoomIn: 4,
+ zoomOut: 4,
+ oneToOne: 4,
+ reset: 4,
+ prev: 4,
+ play: 0,
+ next: 4,
+ rotateLeft: 4,
+ rotateRight: 4,
+ flipHorizontal: 4,
+ flipVertical: 4,
+ }
+ })
+
+ function wrapEventBind (fn: () => void) {
+ return function (this: any) {
+ const element = this.element
+ this.element = window.document.body
+ fn.call(this)
+ this.element = element
+ }
+ }
+
+ const _initList = (viewer as any).initList
+ ;(viewer as any).initList = function (this: any, ...args: any[]) {
+ // hack for viewerjs, when there are too many images, the navbar will be hidden
+ this.options.navbar = this.images.length <= 5
+ this.navbar.style.display = this.options.navbar ? 'block' : 'none'
+ return _initList.apply(viewer, args)
+ }
+
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // @ts-ignore
+ viewer.bind = wrapEventBind(viewer.bind)
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // @ts-ignore
+ viewer.unbind = wrapEventBind(viewer.unbind)
+
+ ctx.registerHook('VIEW_RENDERED', debounce(() => {
+ viewer.update()
+ }, 500))
+ }, 0)
+ })
+
+ ctx.theme.addStyles(`
+ body .viewer-backdrop {
+ background: rgba(var(--g-color-90-rgb), 0.98);
+ }
+
+ body .viewer-title {
+ color: #888;
+ }
+
+ body .viewer-navbar {
+ background: rgba(0, 0, 0, .57)
+ }
+
+ body .viewer-canvas > img {
+ transition: transform .2s;
+ }
+ `)
+
+ // https://github.com/fengyuanchen/viewerjs/issues/197
+ ctx.view.addStyles(`
+ body.viewer-open {
+ padding-right: 0 !important;
+ }
+ `, true)
+
+ ctx.editor.registerCustomEditor({
+ name: 'image-viewer',
+ displayName: 'Image Viewer',
+ hiddenPreview: true,
+ when ({ doc }) {
+ return isImageFile(doc)
+ },
+ component: ImageViewer,
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/insert-table/InsertTable.vue b/src/renderer/plugins/insert-table/InsertTable.vue
new file mode 100644
index 000000000..e2f164651
--- /dev/null
+++ b/src/renderer/plugins/insert-table/InsertTable.vue
@@ -0,0 +1,139 @@
+
+
+
+
+
+
+
+
+
+
+
+ x
+
+
+
+
+
+
+
+
+
diff --git a/src/renderer/plugins/insert-table/index.ts b/src/renderer/plugins/insert-table/index.ts
new file mode 100644
index 000000000..cc965b52b
--- /dev/null
+++ b/src/renderer/plugins/insert-table/index.ts
@@ -0,0 +1,152 @@
+import type { Plugin } from '@fe/context'
+import InsertTable from './InsertTable.vue'
+import { SimpleCompletionItem } from '@fe/services/editor'
+
+export default {
+ name: 'insert-table',
+ register: ctx => {
+ const actionName = 'plugin.insert-table'
+ const editorInsertCommand = 'vs.editor.ICodeEditor:1:' + actionName
+
+ function when () {
+ return !!(ctx.store.state.currentFile && ctx.doc.isMarkdownFile(ctx.store.state.currentFile))
+ }
+
+ function buildTableCompletionItems (): SimpleCompletionItem[] | false {
+ if (!when()) {
+ return []
+ }
+
+ const editor = ctx.editor.getEditor()
+ const position = editor.getPosition()
+ const prev2Lines = ((position && position.lineNumber > 2) ? ctx.editor.getLinesContent(position.lineNumber - 2, position.lineNumber - 1) : '').split('\n')
+ const tableCols = prev2Lines.reduce((acc: number, line: string) => {
+ const cols = line.split('|').length
+ return acc > 0 ? (acc === cols ? cols : -1) : cols
+ }, 0)
+
+ const currentLine = position ? ctx.editor.getLineContent(position.lineNumber) : ''
+
+ let i = 1
+ return /\|[^|]+/.test(currentLine) ? false : tableCols > 1
+ ? [
+ { language: 'markdown', label: '/ ||| Table Row', insertText: prev2Lines[0].replaceAll('\r', '').replace(/[^|]+/g, () => ` \${${i++}:--} `).trim() + '\n', block: true }
+ ]
+ : [
+ { language: 'markdown', label: '/ ||| Table', insertText: '', command: { id: editorInsertCommand, title: ctx.i18n.t('insert-table.insert-table') }, block: true },
+ ]
+ }
+
+ function canInsertTable () {
+ const tableItems = buildTableCompletionItems()
+ return Array.isArray(tableItems) && tableItems[0].command?.id === editorInsertCommand
+ }
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.addAction({
+ id: actionName,
+ contextMenuGroupId: 'modification',
+ label: ctx.i18n.t('insert-table.insert-table'),
+ keybindings: [],
+ run: () => {
+ ctx.action.getActionHandler(actionName)()
+ },
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ const tableItems = buildTableCompletionItems()
+ if (tableItems === false) {
+ return
+ }
+
+ items.push(...tableItems)
+ })
+ })
+
+ function insertTable (params: { rows: number, cols: number, compact: boolean }) {
+ ctx.editor.getEditor().focus()
+
+ if (!canInsertTable()) {
+ return
+ }
+
+ let text = ''
+
+ const position = ctx.editor.getEditor().getPosition()
+ const lineNumber = position?.lineNumber
+ if (lineNumber && lineNumber > 2) {
+ const prevLineIsEmpty = !!(ctx.editor.getLineContent(lineNumber - 1))
+ if (prevLineIsEmpty) {
+ text += '\n'
+ }
+ }
+
+ // table head
+ for (let i = 0; i < params.cols; i++) {
+ text += `| TH_${i + 1} `
+ }
+ text += '|\n'
+
+ // table separator
+ for (let i = 0; i < params.cols; i++) {
+ text += '| -- '
+ }
+ text += '|\n'
+
+ // table body
+ for (let i = 0; i < params.rows; i++) {
+ for (let j = 0; j < params.cols; j++) {
+ text += `| TD_${i + 1}_${j + 1} `
+ }
+ text += '|\n'
+ }
+
+ if (params.compact) {
+ text += '{.small}\n'
+ }
+
+ ctx.editor.insert(text)
+ }
+
+ ctx.action.registerAction({
+ name: actionName,
+ forUser: true,
+ description: ctx.i18n.t('insert-table.insert-table'),
+ handler: () => {
+ if (canInsertTable()) {
+ const params = ctx.lib.vue.ref({ rows: 2, cols: 2, compact: false })
+
+ ctx.ui.useModal().confirm({
+ title: ctx.i18n.t('insert-table.insert-table'),
+ component: () => ctx.lib.vue.h(InsertTable, {
+ onConfirm: () => {
+ ctx.ui.useModal().ok()
+ },
+ onChange: (val: any) => { params.value = val }
+ }),
+ okText: ctx.i18n.t('insert-table.insert'),
+ }).then(val => {
+ if (val) {
+ insertTable(params.value)
+ }
+ })
+ } else {
+ ctx.ui.useToast().show('warning', 'Cannot insert table here')
+ }
+ },
+ when,
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push({
+ id: actionName,
+ type: 'normal',
+ title: ctx.i18n.t('insert-table.insert-table'),
+ hidden: !when(),
+ onClick: () => {
+ ctx.action.getActionHandler(actionName)()
+ },
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-applet.ts b/src/renderer/plugins/markdown-applet.ts
index 328c8b7fd..93ce50ff6 100644
--- a/src/renderer/plugins/markdown-applet.ts
+++ b/src/renderer/plugins/markdown-applet.ts
@@ -1,55 +1,97 @@
-import { h } from 'vue'
-import CryptoJS from 'crypto-js'
-import dayjs from 'dayjs'
+import { defineComponent, h, onBeforeUnmount, ref } from 'vue'
import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { IFrame } from '@fe/context/embed'
+import { registerHook, removeHook } from '@fe/core/hook'
+import { IFrame } from '@fe/support/embed'
+import { md5 } from '@fe/utils'
+import type { Plugin } from '@fe/context'
+import type { RenderEnv } from '@fe/types'
+
+const Applet = defineComponent({
+ name: 'XApplet',
+ props: {
+ appletId: String,
+ html: String,
+ attrs: Object as () => Record,
+ },
+ setup (props) {
+ const displayFlag = ref(false)
+
+ function hide () {
+ displayFlag.value = false
+ }
+
+ function show () {
+ displayFlag.value = true
+ }
+
+ registerHook('DOC_SWITCHED', hide)
+ registerHook('VIEW_BEFORE_REFRESH', hide)
+ registerHook('VIEW_RENDERED', show)
+
+ onBeforeUnmount(() => {
+ removeHook('DOC_SWITCHED', hide)
+ removeHook('VIEW_BEFORE_REFRESH', hide)
+ removeHook('VIEW_RENDERED', show)
+ })
+
+ return () => !displayFlag.value ? null : h(IFrame, {
+ html: props.html,
+ debounce: 1000,
+ globalStyle: true,
+ onLoad (iframe: HTMLIFrameElement) {
+ const win = iframe.contentWindow as any
+ win.appletId = props.appletId
+ win.init?.()
+ win.resize()
+ },
+ iframeProps: {
+ ...props.attrs,
+ class: 'applet-iframe',
+ height: '20px',
+ }
+ })
+ }
+})
const MarkdownItPlugin = (md: Markdown) => {
const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
- md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
const token = tokens[idx]
const code = token.content.trim()
const firstLine = code.split(/\n/)[0].trim()
- if (token.info !== 'html' || !firstLine.includes('--applet--')) {
+ if (token.info !== 'html' || !firstLine.includes('--applet--') || env.safeMode) {
return temp(tokens, idx, options, env, slf)
}
- const hash = CryptoJS.MD5(code).toString()
+ const hash = md5(code)
const appletId = `applet-${hash}-${idx}`
const appletTitle = firstLine.replace('', '').replace('--applet--', '').trim()
const html = `
${code}
`
+ const iframe = h(Applet, {
+ html,
+ appletId,
+ attrs: token.meta?.attrs,
+ })
+
+ if (!appletTitle) {
+ return iframe
+ }
+
return h('fieldset', {}, [
h('legend', {}, `Applet: ${appletTitle}`),
h('div',
{ class: 'applet' },
- h(IFrame, {
- html,
- debounce: 1000,
- globalStyle: true,
- onLoad (iframe: HTMLIFrameElement) {
- const win = iframe.contentWindow as any
- win.appletId = appletId
- win.CryptoJS = CryptoJS
- win.dayjs = dayjs
- win.init?.()
- win.resize()
- },
- iframeProps: {
- class: 'applet-iframe',
- height: '20px',
- }
- }),
+ iframe,
)
]) as any
}
@@ -59,5 +101,13 @@ export default {
name: 'applet',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin)
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` Applet', insertText: '```html\n\n\n```\n', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-code-copy.ts b/src/renderer/plugins/markdown-code-copy.ts
new file mode 100644
index 000000000..8d833360d
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-copy.ts
@@ -0,0 +1,109 @@
+import { h, VNode } from 'vue'
+import { Plugin } from '@fe/context'
+import SvgIcon from '@fe/components/SvgIcon.vue'
+
+export default {
+ name: 'markdown-code-copy',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .p-mcc-copy-btn-wrapper {
+ width: 0;
+ height: 0;
+ position: sticky;
+ left: 100%;
+ top: 0;
+ float: right;
+ }
+
+ .markdown-view .markdown-body .p-mcc-language {
+ position: absolute;
+ top: -11px;
+ right: -8px;
+ opacity: 1;
+ color: var(--g-color-50);
+ font-size: 12px;
+ transition: opacity 200ms;
+ user-select: none;
+ line-height: 1;
+ }
+
+ .markdown-view .markdown-body .p-mcc-copy-btn {
+ width: 20px;
+ height: 20px;
+ position: relative;
+ right: 12px;
+ top: -10px;
+ padding: 6px;
+ border-radius: 50%;
+ opacity: 0;
+ transition: opacity 200ms;
+ display: flex;
+ align-items: center;
+ color: var(--g-color-30)
+ }
+
+ .markdown-view .markdown-body pre:hover .p-mcc-copy-btn {
+ opacity: 1;
+ }
+
+ .markdown-view .markdown-body pre:hover .p-mcc-language {
+ opacity: 0;
+ }
+
+ .markdown-view .markdown-body .p-mcc-copy-btn:hover {
+ background: var(--g-color-80);
+ }
+
+ .markdown-view .markdown-body .svg-icon {
+ width: 18px;
+ height: 18px;
+ display: inline-block;
+ text-align: center;
+ vertical-align: middle;
+ }
+
+ .markdown-view .markdown-body .svg-icon svg {
+ width: 100%;
+ height: 100%;
+ display: inline-block;
+ }
+ `, true)
+
+ ctx.markdown.registerPlugin(md => {
+ const codeInline = (fn: Function) => (tokens: any, idx: any, options: any, env: any, slf: any) => {
+ if (tokens[idx].attrIndex('title') < 0) {
+ tokens[idx].attrJoin('class', ctx.args.DOM_CLASS_NAME.COPY_INNER_TEXT)
+ tokens[idx].attrPush(['title', ctx.keybinding.getKeyLabel('CtrlCmd') + ' + ' + ctx.i18n.t('click-to-copy')])
+ }
+
+ return (fn)(tokens, idx, options, env, slf)
+ }
+
+ const codeBlock = (fn: Function) => (tokens: any, idx: any, options: any, env: any, slf: any) => {
+ const token = tokens[idx]
+ const code = token.content
+ const codeNode: VNode = fn(tokens, idx, options, env, slf) as any
+
+ if (!code.trim()) {
+ return codeNode as any
+ }
+
+ if (codeNode && Array.isArray(codeNode.children)) {
+ codeNode.children.unshift(h('div', { class: 'p-mcc-copy-btn-wrapper skip-print' }, [
+ h('div', { class: 'p-mcc-language' }, token.info),
+ h(
+ 'div',
+ { class: 'p-mcc-copy-btn copy-text', 'data-text': code.replace(/\n$/, ''), title: ctx.i18n.t('copy-code') },
+ h(SvgIcon, { name: 'clipboard', style: 'pointer-events: none' })
+ ),
+ ]))
+ }
+
+ return codeNode as any
+ }
+
+ md.renderer.rules.fence = codeBlock(md.renderer.rules.fence!.bind(md.renderer.rules))
+ md.renderer.rules.code_inline = codeInline(md.renderer.rules.code_inline!.bind(md.renderer.rules))
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code-highlight.ts b/src/renderer/plugins/markdown-code-highlight.ts
new file mode 100644
index 000000000..4af12e1c8
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-highlight.ts
@@ -0,0 +1,285 @@
+import prism from 'prismjs'
+import defaultStyle from 'prismjs/themes/prism.css?inline'
+import { escape } from 'lodash-es'
+import type { Plugin, Ctx } from '@fe/context'
+import { getLogger } from '@fe/utils'
+import styles from '@fe/others/prism-style.scss?inline'
+import '@fe/others/prism-languages-all'
+
+const logger = getLogger('markdown-code-highlight')
+
+const TABLE_NAME = 'hljs-ln'
+const LINE_NAME = 'hljs-ln-line'
+const CODE_BLOCK_NAME = 'hljs-ln-code'
+const NUMBERS_BLOCK_NAME = 'hljs-ln-numbers'
+const NUMBER_LINE_NAME = 'hljs-ln-n'
+const DATA_ATTR_NAME = 'data-line-number'
+const BREAK_LINE_REGEXP = /\r\n|\r|\n/g
+
+function addCustomStyles (ctx: Ctx) {
+ ctx.view.addStyles(`
+ ${styles}
+
+ .markdown-view .markdown-body table.${TABLE_NAME} {
+ margin: 0;
+ border-collapse: separate;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME},
+ .markdown-view .markdown-body table.${TABLE_NAME} tr,
+ .markdown-view .markdown-body table.${TABLE_NAME} td {
+ border: 0;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td {
+ padding: 0;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} tbody {
+ display: table;
+ min-width: 100%;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td.${NUMBERS_BLOCK_NAME} {
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ text-align: center;
+ vertical-align: top;
+ text-align: right;
+ min-width: 2em;
+ width: 2em;
+ position: sticky;
+ left: 0;
+ background-color: var(--g-color-96);
+ box-shadow: -20px 0px 0px var(--g-color-96);
+ border-right: 1px solid var(--g-color-86);
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td.${CODE_BLOCK_NAME} {
+ padding-left: 10px;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} .${NUMBER_LINE_NAME}{
+ white-space: nowrap;
+ padding-right: 8px;
+ color: var(--g-color-40);
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} .${NUMBER_LINE_NAME}:before{
+ content: attr(${DATA_ATTR_NAME})
+ }
+
+ .markdown-view .markdown-body .${ctx.args.DOM_CLASS_NAME.WRAP_CODE} table.${TABLE_NAME} td {
+ white-space: pre-wrap;
+ box-shadow: none !important;
+ }
+
+ @media print {
+ .markdown-view .markdown-body table.${TABLE_NAME} tr {
+ background-color: inherit;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td {
+ white-space: pre-wrap;
+ box-shadow: none !important;
+ }
+ }
+
+ @media screen {
+ .markdown-view .markdown-body table.${TABLE_NAME} {
+ max-height: 400px;
+ }
+ }
+ `)
+}
+
+function getLinesCount (text: string) {
+ return (text.trim().match(BREAK_LINE_REGEXP) || []).length
+}
+
+function getLines (text: string) {
+ if (text.length === 0) return []
+ return text.split(BREAK_LINE_REGEXP)
+}
+
+function addLineNumbersBlockFor (inputHtml: string, firstLineIndex: number, lang: string) {
+ const lines = getLines(inputHtml)
+
+ if (lines.length === 0) {
+ return inputHtml
+ }
+
+ // if last line contains only carriage return remove it
+ if (lines[lines.length - 1].trim() === '') {
+ lines.pop()
+ }
+
+ if (lines.length > firstLineIndex) {
+ let html = ''
+
+ for (let i = 0, l = lines.length; i < l; i++) {
+ html += '' +
+ `` +
+ `` +
+ ' ' +
+ `` +
+ `${lines[i].length > 0 ? lines[i] : ' '}` +
+ ' ' +
+ ' '
+ }
+
+ return `${html}
`
+ }
+
+ return inputHtml
+}
+
+function duplicateMultilineNode (element: HTMLElement) {
+ const className = element.className
+
+ if (!/^token/.test(className)) return
+
+ const lines = getLines(element.innerHTML)
+
+ let result = ''
+ for (let i = 0; i < lines.length; i++) {
+ const lineText = lines[i].length > 0 ? lines[i] : ' '
+ result += `${lineText}\n`
+ }
+
+ element.innerHTML = result.trim()
+}
+
+/**
+ * Recursive method for fix multi-line elements implementation
+ * Doing deep passage on child nodes.
+ */
+function duplicateMultilineNodes (element: HTMLElement) {
+ element.childNodes.forEach(child => {
+ if (child.textContent && getLinesCount(child.textContent) > 0) {
+ if (child.childNodes.length > 0) {
+ duplicateMultilineNodes(child as HTMLElement)
+ } else {
+ duplicateMultilineNode(child.parentNode! as HTMLElement)
+ }
+ }
+ })
+}
+
+function wrap (code: string, lang: string, lineNumber: boolean) {
+ let html = code
+
+ if (lang === 'text') {
+ html = escape(code)
+ }
+
+ if (lineNumber) {
+ const element = document.createElement('code')
+ element.innerHTML = html
+ duplicateMultilineNodes(element)
+ html = addLineNumbersBlockFor(element.innerHTML, 1, lang)
+ }
+
+ return html
+}
+
+const extensionMap: Record = {
+ vue: 'markup',
+ html: 'markup',
+ md: 'markdown',
+ rb: 'ruby',
+ ts: 'typescript',
+ py: 'python',
+ sh: 'bash',
+ yml: 'yaml',
+ styl: 'stylus',
+ kt: 'kotlin',
+ rs: 'rust',
+ node: 'js',
+ asm: 'nasm',
+ s: 'nasm',
+ assembly: 'nasm',
+ masm: 'nasm',
+ bat: 'batch',
+ 'c++': 'cpp',
+}
+
+function getLangCodeFromExtension (extension: string) {
+ return extensionMap[extension] || extension
+}
+
+function highlight (str: string, lang: string, lineNumber: boolean) {
+ if (!lang) {
+ return escape(str)
+ }
+
+ lang = lang.toLowerCase()
+ const rawLang = lang
+
+ lang = getLangCodeFromExtension(lang)
+
+ if (prism.languages[lang]) {
+ const code = prism.highlight(str, prism.languages[lang], lang)
+ return wrap(code, rawLang, lineNumber)
+ } else {
+ logger.warn(`Syntax highlight for language "${lang}" is not supported.`)
+ }
+
+ return wrap(str, 'text', lineNumber)
+}
+
+export default {
+ name: 'markdown-code-highlight',
+ register: (ctx: Ctx) => {
+ addCustomStyles(ctx)
+ ctx.markdown.registerPlugin(md => {
+ md.options.highlight = (str, lang) => highlight(str, lang, true)
+ })
+
+ let supportedLanguages: string
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ if (!supportedLanguages) {
+ supportedLanguages = Object.keys(prism.languages).concat(Object.keys(extensionMap)).sort().join(',').replace('DFS,', '')
+ }
+
+ items.push({ language: 'markdown', label: '/ ``` Code', insertText: '```${1|' + supportedLanguages + '|}\n$2\n```\n', block: true })
+ })
+
+ const exportStyles = `
+ ${defaultStyle}
+ code[class*="language-"], pre[class*="language-"] {
+ text-shadow: none;
+ }
+ `
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node, options }) => {
+ if (node.tagName === 'TABLE' && node.dataset.lang) {
+ const code = node.parentElement
+ ?.parentElement
+ ?.querySelector('.p-mcc-copy-btn.copy-text')
+ ?.dataset
+ ?.text
+
+ if (code) {
+ if (options.highlightCode) {
+ if (options.inlineStyle || options.includeStyle) {
+ node.outerHTML = ctx.lib.juice(
+ highlight(code, node.dataset.lang, false),
+ { extraCss: exportStyles }
+ )
+ } else {
+ node.outerHTML = highlight(code, node.dataset.lang, false)
+ }
+ } else {
+ node.outerHTML = ctx.lib.lodash.escape(code)
+ }
+ }
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code-run.ts b/src/renderer/plugins/markdown-code-run.ts
new file mode 100644
index 000000000..df5c1558f
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-run.ts
@@ -0,0 +1,391 @@
+import { computed, customRef, defineComponent, getCurrentInstance, h, nextTick, onBeforeUnmount, ref, shallowRef, VNode, watch, watchEffect } from 'vue'
+import Markdown from 'markdown-it'
+import { escape, throttle } from 'lodash-es'
+import { Plugin } from '@fe/context'
+import { getActionHandler } from '@fe/core/action'
+import { DOM_CLASS_NAME, FLAG_DISABLE_XTERM } from '@fe/support/args'
+import { CtrlCmd, getKeyLabel, matchKeys } from '@fe/core/keybinding'
+import { useI18n } from '@fe/services/i18n'
+import { getLogger, md5, sleep } from '@fe/utils'
+import SvgIcon from '@fe/components/SvgIcon.vue'
+import { getAllRunners } from '@fe/services/runner'
+import { registerHook, removeHook } from '@fe/core/hook'
+import type { CodeRunner, RenderEnv } from '@fe/types'
+
+const cache: Record = {}
+
+const logger = getLogger('markdown-code-run')
+
+const RunCode = defineComponent({
+ name: 'run-code',
+ props: {
+ code: {
+ type: String,
+ default: ''
+ },
+ language: String,
+ firstLine: String,
+ },
+ setup (props) {
+ const { t } = useI18n()
+ const instance = getCurrentInstance()
+ const result = customRef((track, trigger) => {
+ const _trigger = throttle(trigger, 200, { leading: true, trailing: true })
+ return {
+ get: () => {
+ track()
+ return cache[hash.value] || ''
+ },
+ set: (val: string) => {
+ cache[hash.value] = val
+ _trigger()
+ }
+ }
+ })
+ const abortController = shallowRef()
+ const hash = computed(() => md5(props.language + props.code))
+ const runner = ref()
+ const resultRef = ref()
+ const status = computed(() => runner.value?.nonInterruptible ? 'idle' : (abortController.value ? 'running' : 'idle'))
+ const getTerminalCmd = computed(() => runner.value?.getTerminalCmd(props.language!, props.firstLine!))
+
+ let hasResult = false
+
+ let appendLog: ((type: 'html' | 'plain', res: string) => void) | undefined = (type, res) => {
+ if (type === 'plain') {
+ res = escape(res)
+ }
+
+ let value = result.value
+
+ if (hasResult) {
+ value += res
+ } else {
+ value = res
+ hasResult = true
+ }
+
+ if (value.length > 32 * 1024) {
+ value = '------Output too long, truncated to 32K------\n' + value.slice(-32 * 1024)
+ }
+
+ result.value = value
+ }
+
+ const abort = () => {
+ if (abortController.value && !abortController.value.signal.aborted) {
+ abortController.value.abort()
+ abortController.value = undefined
+ if (!hasResult) {
+ result.value = ''
+ }
+ }
+ }
+
+ const run = async () => {
+ if (status.value === 'running') {
+ abort()
+ return
+ }
+
+ const { code, language } = props
+
+ hasResult = false
+
+ if (!runner.value) {
+ result.value = "No runner found for language '" + language + "'"
+ return
+ }
+
+ result.value = t('code-run.running')
+ await sleep(0)
+
+ try {
+ if (abortController.value) {
+ abort()
+ }
+
+ abortController.value = new AbortController()
+
+ const res = await runner.value.run(language!, code, {
+ signal: abortController.value?.signal,
+ flusher: (type, value) => appendLog?.(type, value)
+ })
+
+ if (!res) {
+ return
+ }
+
+ const { type, value: val } = res
+
+ if (typeof val === 'string') {
+ appendLog?.(type, val)
+ return
+ }
+
+ // read stream
+ while (true) {
+ if (abortController.value && abortController.value.signal.aborted) {
+ break
+ }
+
+ const { done, value } = await val.read()
+ if (done) {
+ logger.debug('run code done >', value)
+ appendLog?.(type, value || '')
+ break
+ }
+
+ logger.debug('run code result >', value)
+
+ if (!appendLog) {
+ break
+ }
+
+ let valStr = value
+
+ if (typeof value !== 'string') {
+ try {
+ valStr = new TextDecoder().decode(value)
+ } catch {
+ valStr = String(value)
+ }
+ }
+
+ appendLog(type, valStr)
+ }
+ } catch (error: any) {
+ if (error.name !== 'AbortError') {
+ appendLog?.('plain', error.message)
+ }
+ } finally {
+ abort()
+ }
+ }
+
+ const runInXterm = (e: MouseEvent) => {
+ const cmd = runner.value?.getTerminalCmd(props.language!, props.firstLine!)
+
+ if (!cmd) {
+ return
+ }
+
+ getActionHandler('xterm.run')({
+ code: props.code,
+ start: cmd.start,
+ exit: matchKeys(e, [CtrlCmd]) ? undefined : cmd.exit,
+ })
+ }
+
+ const clearResult = () => {
+ result.value = ''
+ hasResult = false
+ delete cache[hash.value]
+ instance?.proxy?.$forceUpdate()
+ }
+
+ watch(() => props.code, () => {
+ result.value = ''
+ })
+
+ watch(() => result.value, () => {
+ if (resultRef.value) {
+ // scroll to bottom if near the bottom
+ if (resultRef.value.scrollHeight - resultRef.value.scrollTop - resultRef.value.clientHeight < 50) {
+ nextTick(() => {
+ resultRef.value?.scrollTo(0, resultRef.value.scrollHeight)
+ })
+ }
+ }
+ }, { flush: 'pre' })
+
+ const refreshRunner = () => {
+ runner.value = getAllRunners().find((runner) => runner.match(props.language!, props.firstLine!))
+ }
+
+ const selectRunResult = (e: MouseEvent) => {
+ e.preventDefault()
+ e.stopPropagation()
+ const target = e.currentTarget as HTMLElement
+
+ const selection = target.ownerDocument.defaultView!.getSelection()
+ const range = target.ownerDocument.createRange()
+ range.selectNodeContents(e.currentTarget as HTMLElement)
+ selection?.removeAllRanges()
+ selection?.addRange(range)
+ }
+
+ watchEffect(refreshRunner)
+ registerHook('CODE_RUNNER_CHANGE', refreshRunner)
+
+ onBeforeUnmount(() => {
+ appendLog = undefined
+ abort()
+ removeHook('CODE_RUNNER_CHANGE', refreshRunner)
+ })
+
+ return () => {
+ const runResult = result.value
+
+ return [
+ h('div', { class: `p-mcr-run-code-action ${DOM_CLASS_NAME.SKIP_EXPORT}` }, [
+ h('div', {
+ title: status.value !== 'running' ? t('code-run.run') : t('code-run.stop'),
+ class: 'p-mcr-run-btn' + (status.value === 'running' ? ' p-mcr-run-btn-stop' : ''),
+ onClick: run
+ }),
+ h('div', {
+ title: t('code-run.run-in-xterm-tips', getKeyLabel(CtrlCmd)),
+ class: 'p-mcr-run-xterm-btn skip-print',
+ hidden: !getTerminalCmd.value,
+ onClick: runInXterm
+ }),
+ ]),
+ h('div', { class: `p-mcr-run-code-result ${DOM_CLASS_NAME.SKIP_EXPORT}`, ref: resultRef }, h('output', { onDblclick: selectRunResult, key: runResult, innerHTML: runResult })),
+ h('div', { class: 'p-mcr-clear-btn-wrapper skip-print' }, h(
+ h(
+ 'div',
+ { class: 'p-mcr-clear-btn', style: { display: runResult ? 'flex' : 'none' }, title: t('code-run.clear'), onClick: clearResult },
+ h(SvgIcon, { name: 'times', style: 'pointer-events: none' })
+ ),
+ )),
+ ]
+ }
+ }
+})
+
+const RunPlugin = (md: Markdown) => {
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
+ const token = tokens[idx]
+
+ const code = token.content.trim()
+ const firstLine = code.split(/\n/)[0].trim()
+ if (!firstLine.includes('--run--') || !token.info || env.safeMode) {
+ return temp(tokens, idx, options, env, slf)
+ }
+
+ const codeNode: VNode = temp(tokens, idx, options, env, slf) as any
+
+ if (codeNode && Array.isArray(codeNode.children)) {
+ codeNode.children.push(h(RunCode, {
+ key: code,
+ code,
+ firstLine,
+ language: token.info,
+ }))
+ }
+
+ return codeNode as any
+ }
+}
+
+export default {
+ name: 'markdown-code-run',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .p-mcr-run-code-action {
+ position: sticky;
+ left: 0;
+ border-top: dashed 1px #888;
+ margin: 1em 0;
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-btn {
+ position: absolute;
+ top: -.6em;
+ height: 0;
+ width: 0;
+ border-left: .7em #b7b3b3 solid;
+ border-top: .6em #dddddd00 solid;
+ border-bottom: .6em #dddddd00 solid;
+ border-right: 0;
+ background: rgba(0, 0, 0, 0);
+ cursor: pointer;
+ outline: none;
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-btn.p-mcr-run-btn-stop {
+ border: .56em #b7b3b3 solid;
+ border-radius: 4px;
+ animation: p-mcr-run-btn-stop 1.5s infinite;
+ }
+
+ @keyframes p-mcr-run-btn-stop {
+ 0% { border-color: #b7b3b3; }
+ 50% { border-color: #b7c3f3; }
+ 100% { border-color: #b7b3b3; }
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-xterm-btn {
+ position: absolute;
+ top: -.5em;
+ right: -0;
+ height: 0;
+ width: 0;
+ border-left: .7em #b7b3b3 solid;
+ border-top: .6em #dddddd00 solid;
+ border-bottom: .6em #dddddd00 solid;
+ border-right: 0;
+ background: rgba(0, 0, 0, 0);
+ cursor: pointer;
+ outline: none;transform: rotate(90deg);
+ }
+
+ .markdown-view .markdown-body .p-mcr-clear-btn-wrapper {
+ width: 0;
+ height: 0;
+ position: sticky;
+ left: 100%;
+ bottom: 0;
+ float: right;
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-code-result {
+ position: sticky;
+ left: 0;
+ padding: .5em 0 0 0;
+ max-width: 100%;
+ max-height: 300px;
+ overflow: auto;
+ }
+
+ .markdown-view .markdown-body .p-mcr-clear-btn {
+ width: 20px;
+ height: 20px;
+ position: relative;
+ right: 12px;
+ bottom: 10px;
+ padding: 6px;
+ border-radius: 50%;
+ transition: opacity 200ms;
+ display: flex;
+ align-items: center;
+ color: var(--g-color-20);
+ background: var(--g-color-86);
+ }
+
+ .markdown-view .markdown-body .p-mcr-clear-btn:hover {
+ background: var(--g-color-76);
+ }
+ `, true)
+
+ ctx.markdown.registerPlugin(RunPlugin)
+
+ !FLAG_DISABLE_XTERM && ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
+ editor.addAction({
+ id: 'plugin.editor.run-in-xterm',
+ label: ctx.i18n.t('code-run.run-in-xterm'),
+ contextMenuGroupId: 'other',
+ precondition: 'editorHasSelection',
+ keybindingContext: 'editorHasSelection',
+ keybindings: [
+ monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KeyR
+ ],
+ run: () => {
+ getActionHandler('xterm.run')(editor.getModel()!.getValueInRange(editor.getSelection()!))
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code-wrap.ts b/src/renderer/plugins/markdown-code-wrap.ts
new file mode 100644
index 000000000..87cb35a97
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-wrap.ts
@@ -0,0 +1,41 @@
+import type { Plugin } from '@fe/context'
+import type { FrontMatterAttrs, RenderEnv } from '@fe/types'
+
+export default {
+ name: 'markdown-code-wrap',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .${ctx.args.DOM_CLASS_NAME.WRAP_CODE},
+ .markdown-view .markdown-body .${ctx.args.DOM_CLASS_NAME.WRAP_CODE} ~ .p-mcr-run-code-result {
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ }
+
+ .markdown-view .markdown-body pre > code.${ctx.args.DOM_CLASS_NAME.AVOID_PAGE_BREAK} {
+ page-break-inside: avoid;
+ display: block;
+ }
+
+ @media print {
+ .markdown-view .markdown-body pre > code,
+ .markdown-view .markdown-body .p-mcr-run-code-result {
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ }
+ }
+ `)
+
+ ctx.markdown.registerPlugin(md => {
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
+ const attrs: FrontMatterAttrs = env.attributes!
+ if (attrs.wrapCode) {
+ const token = tokens[idx]
+ token.attrJoin('class', ctx.args.DOM_CLASS_NAME.WRAP_CODE)
+ }
+
+ return temp(tokens, idx, options, env, slf)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code.ts b/src/renderer/plugins/markdown-code.ts
deleted file mode 100644
index e922936e7..000000000
--- a/src/renderer/plugins/markdown-code.ts
+++ /dev/null
@@ -1,226 +0,0 @@
-import Highlight from 'highlight.js'
-import { getKeyLabel } from '@fe/context/shortcut'
-import { Plugin, Ctx } from '@fe/context/plugin'
-import { getLogger } from '@fe/utils'
-
-const logger = getLogger('markdown-code')
-
-Highlight.registerAliases('node', { languageName: 'javascript' })
-
-/* eslint-disable */
-
-// https://github.com/wcoder/highlightjs-line-numbers.js
-
-const TABLE_NAME = 'hljs-ln'
-const LINE_NAME = 'hljs-ln-line'
-const CODE_BLOCK_NAME = 'hljs-ln-code'
-const NUMBERS_BLOCK_NAME = 'hljs-ln-numbers'
-const NUMBER_LINE_NAME = 'hljs-ln-n'
-const DATA_ATTR_NAME = 'data-line-number'
-const BREAK_LINE_REGEXP = /\r\n|\r|\n/g
-
-function addCustomStyles (ctx: Ctx) {
- ctx.theme.addStyles(
- `
- .markdown-view .markdown-body table.${TABLE_NAME},
- .markdown-view .markdown-body table.${TABLE_NAME} tr,
- .markdown-view .markdown-body table.${TABLE_NAME} td {
- border: 0;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} {
- padding-bottom: 10px;
- border-collapse: collaps;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} td {
- padding: 0;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} tbody {
- display: table;
- min-width: 100%;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} td.${NUMBERS_BLOCK_NAME} {
- -webkit-touch-callout: none;
- -webkit-user-select: none;
- -khtml-user-select: none;
- -moz-user-select: none;
- -ms-user-select: none;
- user-select: none;
- text-align: center;
- border-right: 1px solid #777;
- vertical-align: top;
- padding-right: 5px;
- max-width: 45px; width: 35px;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} td.${CODE_BLOCK_NAME} {
- padding-left: 10px;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} .${NUMBER_LINE_NAME}:before{
- content: attr(${DATA_ATTR_NAME})
- }
-
- @media print {
- .markdown-view .markdown-body table.${TABLE_NAME} td {
- white-space: pre-wrap;
- }
- }
-
- @media screen {
- .markdown-view .markdown-body table.${TABLE_NAME} {
- max-height: 400px;
- }
- }
- `
- )
-}
-
-function lineNumbersInternal (element: any, options?: any) {
- // define options or set default
- options = options || {
- singleLine: false
- }
-
- // convert options
- var firstLineIndex = options.singleLine ? 0 : 1
-
- duplicateMultilineNodes(element)
-
- return addLineNumbersBlockFor(element.innerHTML, firstLineIndex)
-}
-
-function addLineNumbersBlockFor (inputHtml: any, firstLineIndex: any) {
- var lines = getLines(inputHtml)
-
- // if last line contains only carriage return remove it
- if (lines[lines.length - 1].trim() === '') {
- lines.pop()
- }
-
- if (lines.length > firstLineIndex) {
- var html = ''
-
- for (var i = 0, l = lines.length; i < l; i++) {
- html += format(
- '' +
- '' +
- '' +
- ' ' +
- '' +
- '{6}' +
- ' ' +
- ' ',
- [
- NUMBERS_BLOCK_NAME,
- LINE_NAME,
- NUMBER_LINE_NAME,
- DATA_ATTR_NAME,
- CODE_BLOCK_NAME,
- i + 1,
- lines[i].length > 0 ? lines[i] : ' '
- ])
- }
-
- return format('{1}
', [ TABLE_NAME, html ])
- }
-
- return inputHtml
-}
-
-/**
- * Recursive method for fix multi-line elements implementation in highlight.js
- * Doing deep passage on child nodes.
- * @param {HTMLElement} element
- */
-function duplicateMultilineNodes (element: any) {
- var nodes = element.childNodes
- for (var node in nodes) {
- if (nodes.hasOwnProperty(node)) {
- var child = nodes[node]
- if (getLinesCount(child.textContent) > 0) {
- if (child.childNodes.length > 0) {
- duplicateMultilineNodes(child)
- } else {
- duplicateMultilineNode(child.parentNode)
- }
- }
- }
- }
-}
-
-/**
- * Method for fix multi-line elements implementation in highlight.js
- * @param {HTMLElement} element
- */
-function duplicateMultilineNode (element: any) {
- var className = element.className
-
- if (!/hljs-/.test(className)) return
-
- var lines = getLines(element.innerHTML)
-
- for (var i = 0, result = ''; i < lines.length; i++) {
- var lineText = lines[i].length > 0 ? lines[i] : ' '
- result += format('{1}\n', [ className, lineText ])
- }
-
- element.innerHTML = result.trim()
-}
-
-function getLines (text: string) {
- if (text.length === 0) return []
- return text.split(BREAK_LINE_REGEXP)
-}
-
-function getLinesCount (text: string) {
- return (text.trim().match(BREAK_LINE_REGEXP) || []).length
-}
-
-/**
- * {@link https://wcoder.github.io/notes/string-format-for-string-formating-in-javascript}
- * @param {string} format
- * @param {array} args
- */
-function format (format: string, args: any) {
- return format.replace(/\{(\d+)\}/g, function (m, n) {
- return args[n] ? args[n] : m
- })
-}
-
-function highlight (str: string, lang: string) {
- if (lang && Highlight.getLanguage(lang)) {
- try {
- const element = document.createElement('code')
- element.innerHTML = Highlight.highlight(lang, str).value
- return lineNumbersInternal(element)
- } catch (error) {
- logger.error(error)
- }
- }
-
- return ''
-}
-
-export default {
- name: 'markdown-code',
- register: (ctx: Ctx) => {
- addCustomStyles(ctx)
- ctx.markdown.registerPlugin(md => {
- const Fun = (fn: Function) => (tokens: any, idx: any, options: any, env: any, slf: any) => {
- if (tokens[idx].attrIndex('title') < 0) {
- tokens[idx].attrJoin('class', 'copy-inner-text')
- tokens[idx].attrPush(['title', getKeyLabel('CtrlCmd') + ' + 单击复制'])
- }
-
- return (fn)(tokens, idx, options, env, slf)
- }
-
- md.renderer.rules.code_inline = Fun(md.renderer.rules.code_inline!.bind(md.renderer.rules))
- md.options.highlight = highlight as any
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-container.ts b/src/renderer/plugins/markdown-container.ts
new file mode 100644
index 000000000..d97138d1f
--- /dev/null
+++ b/src/renderer/plugins/markdown-container.ts
@@ -0,0 +1,385 @@
+import MarkdownItContainer from 'markdown-it-container'
+import { applyAttrs, getAttrs, parseInfo } from 'markdown-it-attributes'
+import { Fragment, h } from 'vue'
+import type Token from 'markdown-it/lib/token'
+import { Plugin } from '@fe/context'
+
+export default {
+ name: 'markdown-container',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .custom-container.section {
+ padding: 12px;
+ border: 1px solid var(--g-color-80);
+ border-radius: var(--g-border-radius);
+ margin-top: 16px;
+ position: relative;
+ }
+
+ .markdown-view .markdown-body .custom-container.section > :first-child {
+ margin-top: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.row {
+ display: flex;
+ justify-content: space-between;
+ position: relative;
+ margin-top: 16px;
+ }
+
+ .markdown-view .markdown-body .custom-container.row.has-title {
+ border-top: 24px solid transparent;
+ }
+
+ .markdown-view .markdown-body .custom-container.row > .custom-container-title {
+ background: var(--g-color-80);
+ position: absolute;
+ padding-left: 8px;
+ margin: 0;
+ font-size: 14px;
+ line-height: 2.2em;
+ left: 0;
+ top: -2.2em;
+ width: 100%;
+ border: 1px solid var(--g-color-80);
+ border-top-left-radius: var(--g-border-radius);
+ border-top-right-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.row > .custom-container.col > .custom-container-title {
+ font-size: 14px;
+ line-height: 1.2;
+ }
+
+ .markdown-view .markdown-body .custom-container.col {
+ width: 100%;
+ padding: 12px;
+ padding-bottom: 0;
+ border: 1px solid var(--g-color-80);
+ border-radius: var(--g-border-radius);
+ margin-right: 8px;
+ background: var(--g-color-100);
+ }
+
+ .markdown-view .markdown-body .custom-container.row.has-title > .custom-container.col {
+ margin-right: -1px;
+ border-radius: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.col:last-of-type,
+ .markdown-view .markdown-body .custom-container.row.has-title > .custom-container.col:last-of-type {
+ margin-right: 0;
+ border-bottom-right-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.row.has-title > .custom-container.col:first-of-type {
+ border-bottom-left-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.details,
+ .markdown-view .markdown-body .custom-container.danger,
+ .markdown-view .markdown-body .custom-container.warning,
+ .markdown-view .markdown-body .custom-container.tip {
+ padding: 2px 16px;
+ padding-top: 16px;
+ margin: 16px 0;
+ border-left-width: 8px;
+ border-left-style: solid;
+ border-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.danger,
+ .markdown-view .markdown-body .custom-container.warning,
+ .markdown-view .markdown-body .custom-container.tip {
+ page-break-inside: avoid;
+ }
+
+ .markdown-view .markdown-body .custom-container-title {
+ font-weight: 600;
+ margin-bottom: 10px;
+ margin-top: -6px;
+ font-size: 1.1em;
+ }
+
+ .markdown-view .markdown-body .custom-container.danger {
+ border-color: #cc0000;
+ background-color: #ffe0e0;
+ color: #660000;
+ }
+
+ .markdown-view .markdown-body .custom-container.warning {
+ border-color: #e7c000;
+ background-color: #fffae3;
+ color: #746000;
+ }
+
+ .markdown-view .markdown-body .custom-container.tip {
+ border-color: #42b983;
+ background-color: var(--g-color-90);
+ color: var(--g-color-10);
+ }
+
+ .markdown-view .markdown-body .custom-container.details {
+ border: none;
+ background-color: var(--g-color-90);
+ padding: 16px 20px;
+ }
+
+ .markdown-view .markdown-body .custom-container.details > summary {
+ margin-top: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.details > summary + *,
+ .markdown-view .markdown-body .custom-container.details > :first-child:not(summary) {
+ margin-top: 16px;
+ }
+
+ .markdown-view .markdown-body .custom-container.details > :last-child:not(summary) {
+ margin-bottom: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.group {
+ position: relative;
+ display: flex;
+ flex-wrap: wrap;
+ margin-bottom: 16px;
+ background: var(--g-color-80);
+ border-radius: var(--g-border-radius);
+ border: 1px solid var(--g-color-80);
+ }
+
+ .markdown-view .markdown-body .custom-container.group p {
+ order: 100;
+ width: 100%;
+ }
+
+ .markdown-view .markdown-body .custom-container.group > .custom-container-title {
+ order: 1;
+ padding-left: 8px;
+ margin: 0;
+ font-size: 14px;
+ line-height: 2.2em;
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-radio {
+ display: none;
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-label {
+ order: 1;
+ cursor: pointer;
+ font-size: 14px;
+ line-height: 2;
+ padding: 0 1em;
+ color: var(--g-color-20);
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-label:hover {
+ background: var(--g-color-85);
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-content {
+ order: 2;
+ width: 100%;
+ display: none;
+ border-radius: var(--g-border-radius);
+ border-top-left-radius: 0;
+ padding: 12px;
+ padding-bottom: 0;
+ background: var(--g-color-100);
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-radio:checked + .group-item-label {
+ background: var(--g-color-100);
+ border-top-left-radius: var(--g-border-radius);
+ border-top-right-radius: var(--g-border-radius);
+ color: var(--g-color-0);
+ font-weight: 500;
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-radio:checked + .group-item-label + .group-item-content {
+ display: block;
+ }
+
+ @media screen {
+ html[app-theme=dark] .markdown-view .markdown-body .custom-container.danger {
+ background-color: #503f3f;
+ color: #d9bebe;
+ }
+
+ html[app-theme=dark] .markdown-view .markdown-body .custom-container.warning {
+ background-color: #4a4738;
+ color: #cbb759;
+ }
+ }
+
+ @media (prefers-color-scheme: dark) {
+ html[app-theme=system] .markdown-view .markdown-body .custom-container.danger {
+ background-color: #503f3f;
+ color: #d9bebe;
+ }
+
+ html[app-theme=system] .markdown-view .markdown-body .custom-container.warning {
+ background-color: #4a4738;
+ color: #cbb759;
+ }
+ }
+ `)
+
+ let groupItemIdx = 0
+ let groupItemSeq = 0
+ let groupItemBase = Date.now()
+ let groupItemName = groupItemBase + groupItemSeq
+ const groupItemContentClass = 'group-item-content'
+
+ ctx.registerHook('MARKDOWN_BEFORE_RENDER', ({ env }) => {
+ // first render, reset count
+ if (env.renderCount === 0) {
+ groupItemBase = Date.now()
+ }
+
+ groupItemSeq = 0
+ })
+
+ function buildGroupItem (token: Token, title: string, attrs?: Record) {
+ const parent = h('div', attrs || Object.fromEntries(token.attrs || []), [])
+ const radioName = `group-item-${groupItemName}`
+ const id = `group-item-${groupItemName}-${groupItemIdx++}`
+ const checked = groupItemIdx === 1 || title.startsWith('*')
+
+ return {
+ node: h(Fragment, [
+ h('input', { key: id, class: 'group-item-radio', id, name: radioName, type: 'radio', 'data-default-checked': checked, checked }),
+ h('label', { class: 'group-item-label', for: id }, title.replace('*', '').trim() || 'Group Item'),
+ parent
+ ]),
+ parent
+ }
+ }
+
+ ctx.markdown.registerPlugin(md => {
+ ['tip', 'warning', 'danger', 'details', 'group-item', 'group', 'row', 'col', 'section', 'div', 'code-group'].forEach(name => {
+ const reg = new RegExp(`^${name}\\s*(.*)$`)
+
+ md.use(MarkdownItContainer, name, {
+ validate: (params: string) => {
+ return reg.test(params.trim())
+ },
+ render: function (tokens: Token[], idx: number) {
+ const token = tokens[idx]
+
+ if (token.nesting === 1) {
+ // TODO: get options
+ const attrsOpts = { leftDelimiter: '{', rightDelimiter: '}', allowedAttributes: undefined }
+
+ // apply attributes
+ const attrInfo = parseInfo(attrsOpts, token.info)
+ if (attrInfo) {
+ const attrs = getAttrs(attrInfo.exp)
+ token.info = attrInfo.text
+ applyAttrs(attrsOpts, token, attrs)
+ }
+
+ const match = token.info.trim().match(reg)
+ const title = md.utils.escapeHtml(match![1])
+ const isGroup = name === 'group' || name === 'code-group'
+
+ const containerClass = isGroup ? 'custom-container group' : `custom-container ${name}`
+
+ if (name === 'group-item') {
+ token.attrJoin('class', groupItemContentClass)
+ return buildGroupItem(token, title)
+ } else if (isGroup) {
+ groupItemIdx = 0
+ groupItemSeq++
+ groupItemName = groupItemBase + groupItemSeq
+ }
+
+ const containerTag = { details: 'details', section: 'section' }[name] || 'div'
+ const titleTag = name === 'details' ? 'summary' : 'p'
+ const titleClass = name === 'details' ? '' : 'custom-container-title'
+
+ const children = (title || isGroup) ? [h(titleTag, { class: titleClass }, title)] : []
+
+ token.attrJoin('class', containerClass)
+ if (title) {
+ token.attrJoin('class', 'has-title')
+ }
+
+ const props: Record = Object.fromEntries(token.attrs || [])
+
+ if (isGroup) {
+ props.key = groupItemName
+ }
+
+ if (name === 'code-group') {
+ for (
+ let i = idx + 1;
+ !(
+ tokens[i].nesting === -1 &&
+ tokens[i].type === 'container_code-group_close'
+ );
+ ++i
+ ) {
+ const token = tokens[i]
+ if (token.type === 'fence' && token.tag === 'code') {
+ if (!token.meta) {
+ token.meta = {}
+ }
+
+ token.meta.isCodeGroupItem = true
+ }
+ }
+ }
+
+ return h(containerTag, props, children)
+ }
+ }
+ })
+ })
+
+ const renderFence = md.renderer.rules.fence!
+ const infoTitleReg = /\[([^\]]*)\]/
+
+ md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ const token = tokens[idx]
+ if (token.meta && token.meta.isCodeGroupItem) {
+ const title = token.info.match(infoTitleReg)?.[1] || token.info || 'txt'
+ token.info = token.info.replace(infoTitleReg, '').trim()
+
+ const groupItem = buildGroupItem(token, title, { class: groupItemContentClass })
+ ;(groupItem.parent.children as any[]).push(
+ renderFence.call(slf, tokens, idx, options, env, slf)
+ )
+
+ return groupItem.node as any
+ }
+
+ return renderFence.call(slf, tokens, idx, options, env, slf)
+ }
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node }) => {
+ if (node.classList.contains('group-item-radio') && node.dataset.defaultChecked === 'true') {
+ node.setAttribute('checked', 'checked')
+ }
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ::: Container', insertText: '${3|:::,::::,:::::|} ${1|tip,warning,danger,details,code-group,group,group-item,row,col,section,div|} ${2:Title}\n${4:Content}\n${3|:::,::::,:::::|}\n', block: true, surroundSelection: '${4:Content}' },
+ { language: 'markdown', label: '/ ::: Group Container', insertText: ':::: group ${1:Title}\n::: group-item Tab 1\ntest 1\n:::\n::: group-item *Tab 2\ntest 2\n:::\n::: group-item Tab 3\ntest 3\n:::\n::::\n', block: true },
+ { language: 'markdown', label: '/ ::: Code Group Container', insertText: '::: code-group ${1:Title}\n${2:```js [test.js]\nlet a = 1\n```\n\n```ts [test.ts]\nlet a: number = 1\n```}\n:::\n', block: true },
+ { language: 'markdown', label: '/ ::: Column Container', insertText: ':::: row ${1:Title}\n::: col\ntest 1\n:::\n::: col\ntest 2\n:::\n::::\n', block: true },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/^:{3,}.*$/, 'tag']
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-drawio.ts b/src/renderer/plugins/markdown-drawio.ts
index 063bb1bab..7ac85ff74 100644
--- a/src/renderer/plugins/markdown-drawio.ts
+++ b/src/renderer/plugins/markdown-drawio.ts
@@ -1,89 +1,52 @@
import Markdown from 'markdown-it'
-import { defineComponent, h, ref, watch } from 'vue'
-import { Plugin } from '@fe/context/plugin'
-import { buildSrc, IFrame } from '@fe/context/embed'
-import * as api from '@fe/support/api'
-import { useBus } from '@fe/support/bus'
-import env from '@fe/utils/env'
-
-const Drawio = defineComponent({
- name: 'drawio',
- props: {
- url: String,
- content: String
- },
- setup (props) {
- const bus = useBus()
- const srcdoc = ref('')
- const iframe = ref()
-
- watch(props, async () => {
- srcdoc.value = await buildSrcdoc({ url: props.url, content: props.content || '' })
- }, { immediate: true })
-
- const resize = () => {
- iframe.value!.contentDocument!.body.style.height = 'auto'
- iframe.value!.contentDocument!.documentElement.style.height = 'auto'
- iframe.value!.height = iframe.value!.contentDocument!.documentElement.offsetHeight + 'px'
- iframe.value!.contentDocument!.body.style.height = iframe.value!.contentDocument!.body.clientHeight + 'px'
- iframe.value!.contentDocument!.documentElement.style.height = '100%'
- bus.emit('global.resize')
+import { h } from 'vue'
+import { Plugin } from '@fe/context'
+import { t } from '@fe/services/i18n'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+
+const MarkdownItPlugin = (md: Markdown) => {
+ const extensionId = '@yank-note/extension-drawio'
+
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
+
+ const render = () => {
+ if (!getInitialized()) {
+ return null
}
- const button = (text: string, onClick: any) => h('button', {
- style: 'margin-left: 5px;font-size: 14px;background: #cacaca; border: 0; padding: 0 6px; color: #2c2b2b; cursor: pointer; border-radius: 2px; transition: all .1s ease-in-out; line-height: 24px;',
- onClick
- }, text)
-
- return () => h('div', { class: 'drawio-wrapper reduce-brightness', style: 'position: relative' }, [
- h(
- 'div',
- {
- class: 'no-print',
- style: 'position: absolute; right: 15px; top: 3px; z-index: 1;'
- },
- [
- button('适应高度', resize),
- button('新窗口打开', () => env.openWindow(buildSrc(srcdoc.value, '查看图形'))),
- ]
- ),
- h(IFrame, {
- html: srcdoc.value,
- onLoad (frame) {
- iframe.value = frame
- resize()
- },
- iframeProps: {
- class: 'drawio',
- height: '300px',
- },
- })
- ])
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'Drawio'))
+ ))
}
-})
-
-const MarkdownItPlugin = (md: Markdown) => {
- const render = ({ url, content }: any) => h(Drawio, { url, content })
const linkTemp = md.renderer.rules.link_open!.bind(md.renderer.rules)
md.renderer.rules.link_open = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return linkTemp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
if (token.attrGet('link-type') !== 'drawio') {
return linkTemp(tokens, idx, options, env, slf)
}
- const url = token.attrGet('href')
const nextToken = tokens[idx + 1]
if (nextToken && nextToken.type === 'text') {
nextToken.content = ''
}
- return render({ url }) as any
+ return render() as any
}
const fenceTemp = md.renderer.rules.fence!.bind(md.renderer.rules)
md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return fenceTemp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
const code = token.content.trim()
@@ -92,92 +55,21 @@ const MarkdownItPlugin = (md: Markdown) => {
return fenceTemp(tokens, idx, options, env, slf)
}
- return render({ content: code }) as any
+ return render() as any
}
}
-type F = { repo?: string; path?: string; url?: string; content: string }
-
-async function buildSrcdoc ({ repo, path, content, url }: F) {
- if (url) {
- content = await (await fetch(url)).text()
- } else if (!content && repo && path) {
- content = (await api.readFile({ repo, path })).content
- }
-
- content = content.replace(//gs, '').trim()
-
- const div = document.createElement('div')
- div.className = 'mxgraph'
- div.dataset.mxgraph = JSON.stringify({
- highlight: '#00afff',
- lightbox: false,
- nav: true,
- resize: true,
- toolbar: 'pages zoom layers',
- page: 1,
- xml: content,
- })
-
- return `
-
- ${div.outerHTML}
-
- `
-}
-
export default {
name: 'markdown-drawio',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin)
- ctx.registerHook('ON_TREE_NODE_SELECT', async (item: any) => {
- if (item.path.toLowerCase().endsWith('.drawio')) {
- const srcdoc = await buildSrcdoc(item)
- env.openWindow(buildSrc(srcdoc, '查看图形'))
-
- return true
- }
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- return false
+ items.push(
+ { language: 'markdown', label: '/ []() Drawio Link', insertText: '[${2:Drawio}]($1){link-type="drawio"}', block: true },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-echarts.ts b/src/renderer/plugins/markdown-echarts.ts
index acd6df74b..d161322eb 100644
--- a/src/renderer/plugins/markdown-echarts.ts
+++ b/src/renderer/plugins/markdown-echarts.ts
@@ -1,114 +1,56 @@
import { h } from 'vue'
-import * as echarts from 'echarts'
-import CryptoJS from 'crypto-js'
-import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { getColorScheme } from '@fe/context/theme'
+import type Markdown from 'markdown-it'
+import type { Plugin } from '@fe/context'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+import { t } from '@fe/services/i18n'
+import { RenderEnv } from '@fe/types'
-const render = (code: string) => {
- const id = `echart-${CryptoJS.MD5(code).toString()}-${Math.random().toString(36).substr(2)}`
+const MarkdownItPlugin = (md: Markdown) => {
+ const extensionId = '@yank-note/extension-echarts'
- return h(
- 'div', { class: 'echarts', id, 'data-code': encodeURIComponent(code) })
-}
-
-const EChartsPlugin = (md: Markdown) => {
- const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
- md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
- const token = tokens[idx]
- const code = token.content.trim()
- if (token.info === 'js' && code.split(/\n/)[0].trim().includes('--echarts--')) {
- return render(code) as any
+ const render = () => {
+ if (!getInitialized()) {
+ return null
}
- return temp(tokens, idx, options, env, slf)
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'ECharts'))
+ ))
}
-}
-
-let charts: {[key: string]: any} = {}
-
-const update = (theme: string | undefined = undefined, animation: boolean | undefined = undefined, renderImg = false) => {
- theme ??= getColorScheme()
-
- Object.values(charts).forEach(x => x.chart.dispose())
- charts = {}
-
- for (const ele of document.getElementsByClassName('echarts')) {
- const el = ele as HTMLDivElement
- try {
- const id = el.getAttribute('id')!
- const code = el.dataset.code
-
- if (code) {
- const chart = echarts.init(el, theme)
- // eslint-disable-next-line
- eval(`(${decodeURIComponent(code)})(chart)`)
-
- if (animation !== undefined) {
- chart.setOption({ animation })
- }
-
- let img = null
- if (renderImg) {
- img = new Image()
- img.width = el.clientWidth
- img.height = el.clientHeight
- img.src = chart.getDataURL({})
- }
-
- charts[id] = { chart, img }
- }
- } catch (error) {
- el.innerText = error
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
+ if (checkExtensionLoaded() || env.safeMode) {
+ return temp(tokens, idx, options, env, slf)
}
- }
-}
-const preparePrint = () => {
- update('light', false, true)
+ const token = tokens[idx]
- for (const ele of document.getElementsByClassName('echarts')) {
- while (ele.firstChild) {
- ele.firstChild.remove()
+ const code = token.content.trim()
+ const firstLine = code.split(/\n/)[0].trim()
+ if (token.info !== 'js' || !firstLine.includes('--echarts--')) {
+ return temp(tokens, idx, options, env, slf)
}
- const id = ele.getAttribute('id')!
-
- if (charts[id] && charts[id].img) {
- ele.appendChild(charts[id].img)
- }
+ return render() as any
}
}
-window.addEventListener('resize', () => {
- Object.values(charts).forEach(x => x.chart.resize())
-})
-
-window.addEventListener('beforeprint', () => {
- update('light', false)
-})
-
export default {
name: 'markdown-echarts',
register: ctx => {
- ctx.theme.addStyles(`
- .markdown-view .markdown-body .echarts {
- width: 100%;
- height: 350px;
- }
- `)
+ ctx.markdown.registerPlugin(MarkdownItPlugin)
- ctx.markdown.registerPlugin(EChartsPlugin)
- ctx.registerHook('ON_VIEW_RENDERED', () => {
- update()
- })
- ctx.registerHook('ON_VIEW_BEFORE_CONVERT', () => {
- preparePrint() // 转换成图片形式，设置主题
- setTimeout(() => update(), 0) // 恢复
- })
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- ctx.bus.on('theme.change', () => update())
+ items.push(
+ { language: 'markdown', label: '/ ``` ECharts', insertText: '```js\n// --echarts-- \nconst option = {\n xAxis: {\n type: "category",\n data: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]\n },\n yAxis: {\n type: "value"\n },\n series: [\n {\n data: [150, 230, 224, 218, 135, 147, 260],\n type: "line"\n }\n ]\n}\n\nchart.setOption(option, true)\n```\n', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-footnote.ts b/src/renderer/plugins/markdown-footnote.ts
index f6e009f53..aee4c50dd 100644
--- a/src/renderer/plugins/markdown-footnote.ts
+++ b/src/renderer/plugins/markdown-footnote.ts
@@ -6,7 +6,7 @@
// https://github.com/markdown-it/markdown-it-footnote/blob/master/index.js
import { createVNode, Fragment } from 'vue'
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
// Process footnotes
//
@@ -131,7 +131,7 @@ function footnote_plugin (md) {
state.env.footnotes.refs[':' + label] = -1
token = new state.Token('footnote_reference_open', '', 1)
- token.meta = { label: label }
+ token.meta = { label }
token.level = state.level++
state.tokens.push(token)
@@ -225,7 +225,7 @@ function footnote_plugin (md) {
state.env.footnotes.list[footnoteId] = {
content: state.src.slice(labelStart, labelEnd),
- tokens: tokens
+ tokens
}
}
@@ -271,7 +271,7 @@ function footnote_plugin (md) {
if (state.env.footnotes.refs[':' + label] < 0) {
footnoteId = state.env.footnotes.list.length
- state.env.footnotes.list[footnoteId] = { label: label, count: 0 }
+ state.env.footnotes.list[footnoteId] = { label, count: 0 }
state.env.footnotes.refs[':' + label] = footnoteId
} else {
footnoteId = state.env.footnotes.refs[':' + label]
@@ -281,7 +281,7 @@ function footnote_plugin (md) {
state.env.footnotes.list[footnoteId].count++
token = state.push('footnote_ref', '', 0)
- token.meta = { id: footnoteId, subId: footnoteSubId, label: label }
+ token.meta = { id: footnoteId, subId: footnoteSubId, label }
}
state.pos = pos
@@ -379,6 +379,13 @@ function footnote_plugin (md) {
export default {
name: 'markdown-footnote',
register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .footnote-backref {
+ padding: 0 4px;
+ font-family: system-ui;
+ vertical-align: middle;
+ }
+ `)
ctx.markdown.registerPlugin(footnote_plugin)
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-front-matter/index.ts b/src/renderer/plugins/markdown-front-matter/index.ts
new file mode 100644
index 000000000..e70bdc187
--- /dev/null
+++ b/src/renderer/plugins/markdown-front-matter/index.ts
@@ -0,0 +1,51 @@
+import type { Options } from 'markdown-it'
+import type { Plugin } from '@fe/context'
+import { processFrontMatter, useMarkdownItRule } from './lib'
+import workerIndexerUrl from './worker-indexer?worker&url'
+
+export default {
+ name: 'markdown-front-matter',
+ register: ctx => {
+ const logger = ctx.utils.getLogger('markdown-front-matter')
+ ctx.markdown.registerPlugin(md => {
+ const render = md.render
+
+ md.render = (src: string, env: any) => {
+ const { attributes } = processFrontMatter(src, env)
+ logger.debug('render', attributes)
+
+ // save origin options
+ const originOptions = { ...md.options }
+
+ // set options
+ if (attributes.mdOptions && typeof attributes.mdOptions === 'object') {
+ Object.assign(md.options, attributes.mdOptions)
+ }
+
+ const result = render.call(md, src, env)
+
+ // clear md.options
+ Object.keys(md.options).forEach(key => {
+ delete md.options[key as keyof Options]
+ })
+
+ // restore origin options
+ Object.assign(md.options, originOptions)
+
+ return result
+ }
+
+ useMarkdownItRule(md)
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ --- Front Matter', insertText: '---\nheadingNumber: true\nwrapCode: true\nenableMacro: true\nmdOptions: { linkify: true, breaks: true }\ndefine:\n APP_NAME: Yank Note\n---\n', block: true },
+ )
+ })
+
+ ctx.indexer.importScriptsToWorker(new URL(workerIndexerUrl, import.meta.url))
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-front-matter/lib.ts b/src/renderer/plugins/markdown-front-matter/lib.ts
new file mode 100644
index 000000000..298009f90
--- /dev/null
+++ b/src/renderer/plugins/markdown-front-matter/lib.ts
@@ -0,0 +1,46 @@
+import frontMatter from 'front-matter'
+import type MarkdownIt from 'markdown-it'
+
+export function processFrontMatter (src: string, env: any) {
+ let bodyBegin = 0
+ let attributes: Record = {}
+ try {
+ const fm = frontMatter(src)
+
+ bodyBegin = fm.bodyBegin - 1
+ if (fm.attributes && typeof fm.attributes === 'object') {
+ attributes = fm.attributes
+ }
+ } catch (error) {
+ console.error(error)
+ }
+
+ let count = 0
+ let bodyBeginPos = 0
+ while (count < bodyBegin) {
+ count++
+ bodyBeginPos = src.indexOf('\n', bodyBeginPos + 1)
+ }
+
+ Object.assign(env, { bodyBegin, bodyBeginPos, attributes, _front_matter_exec_flag: false })
+
+ return { attributes }
+}
+
+export function useMarkdownItRule (md: MarkdownIt) {
+ const firstRule = (md.block.ruler as any).__rules__[0]
+ md.block.ruler.before(firstRule.name, 'front-matter', (state, startLine) => {
+ if (state.env?._front_matter_exec_flag) {
+ return false
+ }
+
+ const bodyBegin = state.env?.bodyBegin || 0
+ if (startLine >= bodyBegin) {
+ return false
+ }
+
+ state.line = bodyBegin
+ state.env._front_matter_exec_flag = true
+ return true
+ })
+}
diff --git a/src/renderer/plugins/markdown-front-matter/worker-indexer.ts b/src/renderer/plugins/markdown-front-matter/worker-indexer.ts
new file mode 100644
index 000000000..c6bdf7cf9
--- /dev/null
+++ b/src/renderer/plugins/markdown-front-matter/worker-indexer.ts
@@ -0,0 +1,14 @@
+import { processFrontMatter, useMarkdownItRule } from './lib'
+import type { IndexerWorkerCtx } from '@fe/others/indexer-worker'
+
+const ctx: IndexerWorkerCtx = self.ctx
+
+ctx.markdown.use(md => {
+ const parse = md.parse
+ md.parse = (src: string, env: any) => {
+ processFrontMatter(src, env)
+ return parse.call(md, src, env)
+ }
+
+ useMarkdownItRule(md)
+})
diff --git a/src/renderer/plugins/markdown-github-alerts.ts b/src/renderer/plugins/markdown-github-alerts.ts
new file mode 100644
index 000000000..4c3201b91
--- /dev/null
+++ b/src/renderer/plugins/markdown-github-alerts.ts
@@ -0,0 +1,49 @@
+import MarkdownItGithubAlerts from 'markdown-it-github-alerts'
+import baseCss from 'markdown-it-github-alerts/styles/github-base.css?inline'
+import lightCss from 'markdown-it-github-alerts/styles/github-colors-light.css?inline'
+import darkCss from 'markdown-it-github-alerts/styles/github-colors-dark-class.css?inline'
+
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'markdown-github-alerts',
+ register: ctx => {
+ ctx.markdown.markdown.use(md => {
+ MarkdownItGithubAlerts(md, { matchCaseSensitive: false })
+ md.renderer.rules.alert_open = function (tokens, idx) {
+ const { title, type, icon } = tokens[idx].meta
+ return ctx.lib.vue.h('div', { class: `markdown-alert markdown-alert-${type}` }, [
+ ctx.lib.vue.h('p', { class: 'markdown-alert-title' }, [
+ ctx.lib.vue.h('span', { class: 'markdown-alert-icon', innerHTML: icon }),
+ title
+ ])
+ ]) as any
+ }
+ })
+
+ const darkVars = (darkCss as unknown as string).replace('.dark', '')
+ ctx.view.addStyles(`
+ ${baseCss}
+ ${lightCss}
+ @media screen { html[app-theme=dark] ${darkVars} }
+ @media (prefers-color-scheme: dark) { html[app-theme=system] ${darkVars} }
+
+ .markdown-alert {
+ avoid-break-inside: avoid;
+ }
+ `)
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+ items.push(
+ {
+ language: 'markdown',
+ label: '/ > Github Alerts',
+ insertText: '> [!${1|NOTE,TIP,IMPORTANT,WARNING,CAUTION|}]${2}\n> ${3:Content}\n',
+ block: true,
+ surroundSelection: (snippet, selection, model) => snippet.replace('> ${3:Content}', model.getValueInRange(selection).replaceAll(/^/gm, '> ')),
+ },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-heading-number.ts b/src/renderer/plugins/markdown-heading-number.ts
new file mode 100644
index 000000000..f78755fc5
--- /dev/null
+++ b/src/renderer/plugins/markdown-heading-number.ts
@@ -0,0 +1,115 @@
+import type { Plugin } from '@fe/context'
+import type { FrontMatterAttrs } from '@fe/types'
+
+export default {
+ name: 'markdown-heading-number',
+ register: ctx => {
+ ctx.theme.addStyles(`
+ .outline-toc {
+ counter-reset: outline-h2counter outline-h3counter outline-h4counter outline-h5counter outline-h6counter;
+ }
+
+ .outline-toc .tag-h1.show-number { counter-set: outline-h2counter; }
+ .outline-toc .tag-h2.show-number { counter-set: outline-h3counter; }
+ .outline-toc .tag-h3.show-number { counter-set: outline-h4counter; }
+ .outline-toc .tag-h4.show-number { counter-set: outline-h5counter; }
+ .outline-toc .tag-h5.show-number { counter-set: outline-h6counter; }
+
+ .outline-toc .tag-h2.show-number:before {
+ counter-increment: outline-h2counter;
+ content: counter(outline-h2counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h3.show-number:before {
+ counter-increment: outline-h3counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h4.show-number:before {
+ counter-increment: outline-h4counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) "."
+ counter(outline-h4counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h5.show-number:before {
+ counter-increment: outline-h5counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) "."
+ counter(outline-h4counter) "."
+ counter(outline-h5counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h6.show-number:before {
+ counter-increment: outline-h6counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) "."
+ counter(outline-h4counter) "."
+ counter(outline-h5counter) "."
+ counter(outline-h6counter) ".\\0000a0\\0000a0";
+ }
+ `)
+
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body {
+ counter-reset: h2counter h3counter h4counter h5counter h6counter;
+ }
+
+ .markdown-view .markdown-body h1.show-number { counter-set: h2counter; }
+ .markdown-view .markdown-body h2.show-number { counter-set: h3counter; }
+ .markdown-view .markdown-body h3.show-number { counter-set: h4counter; }
+ .markdown-view .markdown-body h4.show-number { counter-set: h5counter; }
+ .markdown-view .markdown-body h5.show-number { counter-set: h6counter; }
+
+ .markdown-view .markdown-body h2.show-number:before {
+ counter-increment: h2counter;
+ content: counter(h2counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h3.show-number:before {
+ counter-increment: h3counter;
+ content: counter(h2counter) "."
+ counter(h3counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h4.show-number:before {
+ counter-increment: h4counter;
+ content: counter(h2counter) "."
+ counter(h3counter) "."
+ counter(h4counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h5.show-number:before {
+ counter-increment: h5counter;
+ content: counter(h2counter) "."
+ counter(h3counter) "."
+ counter(h4counter) "."
+ counter(h5counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h6.show-number:before {
+ counter-increment: h6counter;
+ content: counter(h2counter) "."
+ counter(h3counter) "."
+ counter(h4counter) "."
+ counter(h5counter) "."
+ counter(h6counter) ".\\0000a0\\0000a0";
+ }
+ `)
+
+ ctx.markdown.registerPlugin(md => {
+ const headingOpen = md.renderer.rules.heading_open!
+
+ md.renderer.rules.heading_open = function (tokens, idx, opt, env, slf) {
+ const attrs: FrontMatterAttrs = env.attributes
+ if (attrs.headingNumber) {
+ const token = tokens[idx]
+ token.attrJoin('class', 'show-number')
+ }
+
+ return headingOpen.call(this, tokens, idx, opt, env, slf)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-html.ts b/src/renderer/plugins/markdown-html.ts
index c98f8a57b..c28320885 100644
--- a/src/renderer/plugins/markdown-html.ts
+++ b/src/renderer/plugins/markdown-html.ts
@@ -1,9 +1,10 @@
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
import StateBlock from 'markdown-it/lib/rules_block/state_block'
import StateInline from 'markdown-it/lib/rules_inline/state_inline'
import Token from 'markdown-it/lib/token'
import ParserInline from 'markdown-it/lib/parser_inline'
import MarkdownIt from 'markdown-it'
+import { RenderEnv } from '@fe/types'
const unquoted = '[^"\'=<>`\\x00-\\x20]+'
const singleQuoted = "'[^']*'"
@@ -16,69 +17,112 @@ const attribute = '(?:\\s+' + attrName + '(?:\\s*=\\s*' + attrValue + ')?)'
const selfCloseTag = '<(?:area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\b'
const openTag = '<([A-Za-z][A-Za-z0-9\\-]*)' + attribute + '*\\s*\\/?>'
const closeTag = '<\\/([A-Za-z][A-Za-z0-9\\-]*)\\s*>'
-const comment = '|'
+const comment = '(?:)'
-const HTML_TAG_RE = new RegExp('^(?:' + openTag + '|' + closeTag + '|' + comment + ')')
+const HTML_TAG_RE = new RegExp('^(?:' + comment + '|' + openTag + '|' + closeTag + ')')
const HTML_SELF_CLOSE_TAG_RE = new RegExp('^' + selfCloseTag, 'i')
+const INVALID_HTML_TAG_NAME_RE = /script/i
+const INVALID_ATTR_NAME_RE = /^on|^xmlns$|^xml$|^aria-|^srcdoc$/i
+const MULTI_LINE_TAG_RE = /^[^<]*<[A-Za-z][A-Za-z0-9]{0,20}[^>]*$/
+
+const SAFE_MODE_ALLOWED_TAGS = [
+ 'br', 'b', 'i', 'strong', 'em', 'a', 'pre', 'code', 'img',
+ 'tt', 'div', 'ins', 'del', 'sup', 'sub', 'p', 'ol', 'ul',
+ 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'h7', 'h8',
+ 'table', 'thead', 'tbody', 'tfoot', 'blockquote', 'dl', 'dt', 'dd', 'kbd',
+ 'q', 'samp', 'var', 'hr', 'ruby', 'rt', 'rp', 'li', 'tr', 'td', 'th', 's',
+ 'strike', 'summary', 'details', 'caption', 'figure', 'figcaption', 'abbr', 'bdo', 'cite',
+ 'dfn', 'mark', 'small', 'span', 'time', 'wbr',
+]
function isLetter (ch: number) {
const lc = ch | 0x20 // to lower case
return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)
}
-function htmlInline (state: StateInline): boolean {
+function setAttrs (token: Token, content: string) {
+ const div = document.createElement('template')
+ div.innerHTML = content
+
+ const element = div.content.firstElementChild
+ if (!element) {
+ return
+ }
+
+ const attrs: [string, any][] = []
+ for (let i = 0; i < element.attributes.length; i++) {
+ const attr = element.attributes[i]
+
+ if (validateAttrName(attr.name)) {
+ attrs.push([attr.name, attr.value])
+ }
+
+ token.attrs = attrs
+ }
+}
+
+function validateTagName (name: string) {
+ return !INVALID_HTML_TAG_NAME_RE.test(name)
+}
+
+function validateAttrName (name: string) {
+ return !INVALID_ATTR_NAME_RE.test(name.trim())
+}
+
+function htmlInline (state: StateInline, silent = false): boolean {
+ if (silent) { return false }
+
const pos = state.pos
if (!state.md.options.html) { return false }
- // Check start
const max = state.posMax
- if (state.src.charCodeAt(pos) !== 0x3C/* < */ || pos + 2 >= max) {
+
+ // Check start
+ let ch = state.src.charCodeAt(pos)
+ if (pos + 2 >= max || (ch !== 0x3C/* < */ && ch !== 0x2D/* - */)) {
return false
}
// Quick fail on second char
- const ch = state.src.charCodeAt(pos + 1)
- if (ch !== 0x21/* ! */ && ch !== 0x3F/* ? */ && ch !== 0x2F/* / */ && !isLetter(ch)) {
+ ch = state.src.charCodeAt(pos + 1)
+ if (ch !== 0x2D/* - */ && ch !== 0x21/* ! */ && ch !== 0x3F/* ? */ && ch !== 0x2F/* / */ && !isLetter(ch)) {
return false
}
const match = state.src.slice(pos).match(HTML_TAG_RE)
if (!match) { return false }
- const content = state.src.slice(pos, pos + match[0].length)
-
- // ignore comment
- if (content.startsWith('', pos)
+ if (idx < 0) {
+ return false
+ } else {
+ state.pos = idx + 3
+ return true
}
}
const prevHtmlTags = (state.md as any)._prev_inline_html_tags
let token: Token
- if (content.startsWith('')) {
+ if (!validateTagName(tag)) {
+ return false
+ }
+
const prevHtmlTag = prevHtmlTags.pop()
+
if (prevHtmlTags && prevHtmlTag === tag) {
token = state.push('html_close', tag, -1)
} else {
@@ -86,19 +130,52 @@ function htmlInline (state: StateInline): boolean {
return false
}
} else if (content.endsWith('/>') || HTML_SELF_CLOSE_TAG_RE.test(content)) {
+ if (!validateTagName(tag)) {
+ return false
+ }
+
token = state.push('html_self', tag, 0)
} else {
+ if (!validateTagName(tag)) {
+ return false
+ }
+
token = state.push('html_open', tag, 1)
prevHtmlTags.push(tag)
}
token.content = content
- setAttrs(token)
+ setAttrs(token, content)
state.pos += match[0].length
return true
}
+function getMultiLineTag (args: {lineText: string, line: number, endLine: number, state: StateBlock, pos: number}) {
+ let { lineText, line, endLine, state, pos } = args
+
+ let currentLine = lineText
+
+ do {
+ // don't allow empty line
+ if (currentLine.length === 0 || state.sCount[line] < state.blkIndent) {
+ return false
+ }
+
+ if (currentLine.includes('>')) {
+ lineText = state.src.slice(pos, state.eMarks[line])
+ return { lineText, line }
+ }
+
+ line++
+ if (line >= endLine) {
+ return false
+ }
+
+ currentLine = state.src.slice(state.bMarks[line], state.eMarks[line])
+ } while (true)
+}
+
function htmlBlock (state: StateBlock, startLine: number, endLine: number) {
let nextLine; let lineText
let pos = state.bMarks[startLine] + state.tShift[startLine]
@@ -109,26 +186,67 @@ function htmlBlock (state: StateBlock, startLine: number, endLine: number) {
if (!state.md.options.html) { return false }
if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
+ lineText = state.src.slice(pos, max)
+ nextLine = startLine
+
+ // multi-line comment detected
+ if (lineText.startsWith('')) {
+ for (; nextLine < endLine; nextLine++) {
+ pos = state.bMarks[nextLine] + state.tShift[nextLine]
+ max = state.eMarks[nextLine]
+ lineText = state.src.slice(pos, max)
+
+ if (lineText.endsWith('-->')) {
+ nextLine++
+ const token = state.push('comment', '', 0)
+ token.hidden = true
+ token.map = [startLine, nextLine]
+ break
+ }
+ }
+
+ state.line = nextLine
+ return true
+ }
+
+ const multiLineTag = getMultiLineTag({ lineText, line: nextLine, endLine, state, pos })
+ if (multiLineTag) {
+ lineText = multiLineTag.lineText
+ nextLine = multiLineTag.line + 1
+ } else {
+ return false
+ }
+
const inlineParse: any = state.md.inline.parse.bind(state.md.inline)
const pushState = state.push
const prevHtmlTags = (state.md as any)._prev_block_html_tags
- lineText = state.src.slice(pos, max)
- // 调用行内解析规则
+ // invoke inline parse function
inlineParse(lineText, state.md, state.env, state.tokens, prevHtmlTags, pushState)
// If we are here - we detected HTML block.
- for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
+ for (; nextLine < endLine; nextLine++) {
if (state.sCount[nextLine] < state.blkIndent) { break }
pos = state.bMarks[nextLine] + state.tShift[nextLine]
max = state.eMarks[nextLine]
lineText = state.src.slice(pos, max)
+ // break if it's empty line when previous tag is empty or the empty line is flowing tag
if (lineText.length === 0) {
break
}
+ if (MULTI_LINE_TAG_RE.test(lineText)) {
+ const multiLineTag = getMultiLineTag({ lineText, line: nextLine, endLine, state, pos })
+ if (multiLineTag) {
+ lineText = multiLineTag.lineText
+ nextLine = multiLineTag.line
+ } else {
+ return false
+ }
+ }
+
inlineParse(lineText, state.md, state.env, state.tokens, prevHtmlTags, pushState)
}
@@ -143,12 +261,12 @@ function htmlBlock (state: StateBlock, startLine: number, endLine: number) {
}
function inlineParse (this: ParserInline, src: string, md: any, env: any, outTokens: Token[], prevHtmlTags: string[], htmlBlock: boolean) {
- // 每次解析 inline 时候，重置或者使用外部的 html 标签堆栈
+ // restore or use external tag stack every time.
md._prev_inline_html_tags = prevHtmlTags || []
const state = new this.State(src, md, env, outTokens)
- // 如果是 html block 规则调用的，这里 hack 一下，避免 delimiters 为 undefined
+ // hack avoid delimiters to be undefined when html block called.
if (htmlBlock) {
Object.defineProperty(state, 'delimiters', {
get () {
@@ -168,7 +286,7 @@ function inlineParse (this: ParserInline, src: string, md: any, env: any, outTok
}
function parse (this: any, src: string, env: any) {
- // 每次运行解析程序，设定一个 block html 标签栈，便于后续处理程序匹配标签
+ // create block html tag stack for flow up process
this._prev_block_html_tags = []
return MarkdownIt.prototype.parse.call(this, src, env)
}
diff --git a/src/renderer/plugins/markdown-imsize.ts b/src/renderer/plugins/markdown-imsize.ts
new file mode 100644
index 000000000..fbd9be3e3
--- /dev/null
+++ b/src/renderer/plugins/markdown-imsize.ts
@@ -0,0 +1,279 @@
+// https://github.com/tatsy/markdown-it-imsize/blob/master/lib/index.js
+/* eslint-disable no-mixed-operators */
+/* eslint-disable prefer-const */
+/* eslint-disable camelcase */
+/* eslint-disable @typescript-eslint/no-var-requires */
+// Process 
+// ^^^^^^^^ this size specification
+
+import { Plugin } from '@fe/context'
+
+'use strict'
+
+function parseNextNumber (str: any, pos: any, max: any) {
+ let code
+ let start = pos
+ let result = {
+ ok: false,
+ pos,
+ value: ''
+ }
+
+ code = str.charCodeAt(pos)
+
+ while (pos < max && (code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) || code === 0x25 /* % */) {
+ code = str.charCodeAt(++pos)
+ }
+
+ result.ok = true
+ result.pos = pos
+ result.value = str.slice(start, pos)
+
+ return result
+}
+
+function parseImageSize (str: any, pos: any, max: any) {
+ let code
+ let result = {
+ ok: false,
+ pos: 0,
+ width: '',
+ height: ''
+ }
+
+ if (pos >= max) { return result }
+
+ code = str.charCodeAt(pos)
+
+ if (code !== 0x3d /* = */) { return result }
+
+ pos++
+
+ // size must follow = without any white spaces as follows
+ // (1) =300x200
+ // (2) =300x
+ // (3) =x200
+ code = str.charCodeAt(pos)
+ if (code !== 0x78 /* x */ && (code < 0x30 || code > 0x39) /* [0-9] */) {
+ return result
+ }
+
+ // parse width
+ let resultW = parseNextNumber(str, pos, max)
+ pos = resultW.pos
+
+ // next charactor must be 'x'
+ code = str.charCodeAt(pos)
+ if (code !== 0x78 /* x */) { return result }
+
+ pos++
+
+ // parse height
+ let resultH = parseNextNumber(str, pos, max)
+ pos = resultH.pos
+
+ result.width = resultW.value
+ result.height = resultH.value
+ result.pos = pos
+ result.ok = true
+ return result
+}
+
+function image_with_size (md: any) {
+ return function (state: any, silent: any) {
+ let attrs
+ let code
+ let label
+ let labelEnd
+ let labelStart
+ let pos
+ let ref
+ let res
+ let title
+ let width = ''
+ let height = ''
+ let token
+ let tokens: any
+ let start
+ let href = ''
+ const oldPos = state.pos
+ const max = state.posMax
+
+ if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }
+ if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }
+
+ labelStart = state.pos + 2
+ labelEnd = md.helpers.parseLinkLabel(state, state.pos + 1, false)
+
+ // parser failed to find ']', so it's not a valid link
+ if (labelEnd < 0) { return false }
+
+ pos = labelEnd + 1
+ if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
+ //
+ // Inline link
+ //
+
+ // [link]( "title" )
+ // ^^ skipping these spaces
+ pos++
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+ if (pos >= max) { return false }
+
+ // [link]( "title" )
+ // ^^^^^^ parsing link destination
+ start = pos
+ res = md.helpers.parseLinkDestination(state.src, pos, state.posMax)
+ if (res.ok) {
+ href = state.md.normalizeLink(res.str)
+ if (state.md.validateLink(href)) {
+ pos = res.pos
+ } else {
+ href = ''
+ }
+ }
+
+ // [link]( "title" )
+ // ^^ skipping these spaces
+ start = pos
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+
+ // [link]( "title" )
+ // ^^^^^^^ parsing link title
+ res = md.helpers.parseLinkTitle(state.src, pos, state.posMax)
+ if (pos < max && start !== pos && res.ok) {
+ title = res.str
+ pos = res.pos
+
+ // [link]( "title" )
+ // ^^ skipping these spaces
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+ } else {
+ title = ''
+ }
+
+ // [link]( "title" =WxH )
+ // ^^^^ parsing image size
+ if (pos - 1 >= 0) {
+ code = state.src.charCodeAt(pos - 1)
+
+ // there must be at least one white spaces
+ // between previous field and the size
+ if (code === 0x20) {
+ res = parseImageSize(state.src, pos, state.posMax)
+ if (res.ok) {
+ width = res.width
+ height = res.height
+ pos = res.pos
+
+ // [link]( "title" =WxH )
+ // ^^ skipping these spaces
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+ }
+ }
+ }
+
+ if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
+ state.pos = oldPos
+ return false
+ }
+ pos++
+ } else {
+ //
+ // Link reference
+ //
+ if (typeof state.env.references === 'undefined') { return false }
+
+ // [foo] [bar]
+ // ^^ optional whitespace (can include newlines)
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+
+ if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
+ start = pos + 1
+ pos = md.helpers.parseLinkLabel(state, pos)
+ if (pos >= 0) {
+ label = state.src.slice(start, pos++)
+ } else {
+ pos = labelEnd + 1
+ }
+ } else {
+ pos = labelEnd + 1
+ }
+
+ // covers label === '' and label === undefined
+ // (collapsed reference link and shortcut reference link respectively)
+ if (!label) { label = state.src.slice(labelStart, labelEnd) }
+
+ ref = state.env.references[md.utils.normalizeReference(label)]
+ if (!ref) {
+ state.pos = oldPos
+ return false
+ }
+ href = ref.href
+ title = ref.title
+ }
+
+ //
+ // We found the end of the link, and know for a fact it's a valid link;
+ // so all that's left to do is to call tokenizer.
+ //
+ if (!silent) {
+ state.pos = labelStart
+ state.posMax = labelEnd
+
+ const newState = new state.md.inline.State(
+ state.src.slice(labelStart, labelEnd),
+ state.md,
+ state.env,
+ tokens = []
+ )
+ newState.md.inline.tokenize(newState)
+
+ token = state.push('image', 'img', 0)
+ token.attrs = attrs = [['src', href],
+ ['alt', '']]
+ token.children = tokens
+ if (title) {
+ attrs.push(['title', title])
+ }
+
+ if (width !== '') {
+ attrs.push(['width', width])
+ }
+
+ if (height !== '') {
+ attrs.push(['height', height])
+ }
+ }
+
+ state.pos = pos
+ state.posMax = max
+ return true
+ }
+}
+
+function imsize_plugin (md: any) {
+ md.inline.ruler.before('emphasis', 'image', image_with_size(md))
+}
+
+export default {
+ name: 'markdown-imsize',
+ register: ctx => {
+ ctx.markdown.registerPlugin(imsize_plugin)
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-katex.ts b/src/renderer/plugins/markdown-katex.ts
index 6f58ecbe4..b2a846d8d 100644
--- a/src/renderer/plugins/markdown-katex.ts
+++ b/src/renderer/plugins/markdown-katex.ts
@@ -13,8 +13,14 @@ for rendering output.
*/
import katex from 'katex'
+import 'katex/contrib/mhchem/mhchem.js'
import { h } from 'vue'
-import { Plugin } from '@fe/context/plugin'
+import type { Plugin } from '@fe/context'
+import type Token from 'markdown-it/lib/token'
+import styles from 'katex/dist/katex.min.css?inline'
+import monacoLatex from '@fe/others/monaco-latex'
+import { getRenderCache } from '@fe/services/renderer'
+import { triggerHook } from '@fe/core/hook'
// Test if potential opening or closing delimieter
// Assumes that there is a "$" at state.src[pos]
@@ -38,8 +44,8 @@ function isValidDelim (state: any, pos: number) {
}
return {
- can_open: can_open,
- can_close: can_close
+ can_open,
+ can_close
}
}
@@ -99,7 +105,7 @@ function math_inline (state: any, silent: boolean) {
token.markup = '$'
token.content = state.src.slice(start, match)
- // 如果本行字符串以 $ 结尾，避免 markdown-it-attrs 解析，插入一个空白节点
+ // if ends with `$`, insert empty node to avoid markdown-it-attrs parse
if (state.src.endsWith('$')) {
state.push('text', '', 0)
}
@@ -159,40 +165,62 @@ function math_block (state: any, start: number, end: number, silent: boolean) {
return true
}
-function math_plugin (md: any, options: any) {
- // Default options
+function renderToString (latex: string, options: any) {
+ const cacheKey = JSON.stringify(options) + latex
- options = options || {}
+ const innerHTML = getRenderCache('plugin-katex', cacheKey, () => {
+ const payload = { latex, options }
+ triggerHook('PLUGIN_HOOK', { plugin: 'markdown-katex', type: 'before-render', payload })
+ latex = payload.latex
+ options = payload.options
+
+ const html = katex.renderToString(latex, options)
+
+ // block
+ if (options.displayMode) {
+ return html
+ }
+
+ // inline
+ return html.replace(/^/, '')
+ .replace(/<\/span>$/, '')
+ })
+
+ return { cacheKey, innerHTML }
+}
+
+function math_plugin (md: any) {
// set KaTeX as the renderer for markdown-it-simplemath
- const katexInline = function (latex: any) {
- options.displayMode = false
+ const inlineRenderer = function (tokens: Token[], idx: number, _: any, env: any) {
+ const latex = tokens[idx].content
+
+ const { katex = {} } = env.attributes || {}
+ const options = Object.assign({ displayMode: false }, katex)
+
try {
- return katex.renderToString(latex, options)
- } catch (error) {
- if (options.throwOnError) { console.error(error) }
+ const { innerHTML, cacheKey } = renderToString(latex, options)
+ return h('span', { class: 'katex', key: idx + cacheKey, innerHTML })
+ } catch (error: any) {
return h('code', {}, `${error.message} [${latex}]`)
}
}
- const inlineRenderer = function (tokens: any, idx: any) {
- return katexInline(tokens[idx].content)
- }
+ const blockRenderer = function (tokens: Token[], idx: number, _: any, env: any) {
+ const token = tokens[idx]
+ const latex = token.content
+
+ const { katex = {} } = env.attributes || {}
+ const options = Object.assign({ displayMode: true }, katex)
- const katexBlock = function (latex: any) {
- options.displayMode = true
try {
- return '' + katex.renderToString(latex, options) + '
'
- } catch (error) {
- if (options.throwOnError) { console.error(error) }
+ const { innerHTML, cacheKey } = renderToString(latex, options)
+ return h('p', { ...token.meta?.attrs, key: idx + cacheKey, innerHTML }, '')
+ } catch (error: any) {
return h('code', {}, `${error.message} [${latex}]`)
}
}
- const blockRenderer = function (tokens: any, idx: any) {
- return katexBlock(tokens[idx].content) + '\n'
- }
-
md.inline.ruler.after('escape', 'math_inline', math_inline)
md.block.ruler.after('blockquote', 'math_block', math_block, {
alt: ['paragraph', 'reference', 'blockquote', 'list']
@@ -204,11 +232,43 @@ function math_plugin (md: any, options: any) {
export default {
name: 'markdown-katex',
register: ctx => {
- ctx.theme.addStyles(`
+ ctx.view.addStyles(`
+ ${styles}
+
.markdown-view .markdown-body .katex {
background: initial;
}
`)
+
ctx.markdown.registerPlugin(math_plugin, { throwOnError: true })
+
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monacoLatex(monaco)
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'latex', label: '/ \\begin KaTeX Environment', insertText: '\\begin{$1}\n$2\n\\end{$1}', block: true },
+ { language: 'markdown', label: '/ $ Inline KaTeX', insertText: '$$1$' },
+ { language: 'markdown', label: '/ $$ Block KaTeX', insertText: '$$$1$$\n', block: true },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/\$\$/, { token: 'tag', next: '@latexBlockEnd', nextEmbedded: 'latex' }],
+ [/\$(?=\S)/, { token: 'tag', next: '@latexInlineEnd', nextEmbedded: 'latex' }],
+ )
+
+ mdLanguage.tokenizer.latexBlockEnd = [
+ [/\$\$/, { token: 'tag', next: '@pop', nextEmbedded: '@pop' }],
+ ]
+
+ mdLanguage.tokenizer.latexInlineEnd = [
+ [/\$/, { token: 'tag', next: '@pop', nextEmbedded: '@pop' }],
+ ]
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-link.ts b/src/renderer/plugins/markdown-link.ts
deleted file mode 100644
index d0e155ad8..000000000
--- a/src/renderer/plugins/markdown-link.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-import StateCore from 'markdown-it/lib/rules_core/state_core'
-import Token from 'markdown-it/lib/token'
-import { Plugin, Ctx } from '@fe/context/plugin'
-import store from '@fe/support/store'
-import env from '@fe/utils/env'
-import { basename, dirname, join } from '@fe/utils/path'
-import { switchDoc } from '@fe/context/document'
-
-const handleLink = (link: HTMLAnchorElement) => {
- const { currentFile } = store.state
- if (!currentFile) {
- return
- }
-
- const { repo: fileRepo, path: filePath } = currentFile
-
- // 系统中打开附件
- if (link.classList.contains('open')) {
- fetch(link.href.replace('api/attachment', 'api/open'))
- return true
- }
-
- const href = link.getAttribute('href') || ''
-
- if (/^(http:|https:|ftp:)\/\//i.test(href)) { // 处理外链
- // Electron 中打开外链
- if (env.isElectron) {
- env.require && env.require('opn')(link.href)
- return true
- }
- } else { // 处理相对链接
- if (/(\.md$|\.md#)/.test(href)) { // 处理打开相对 md 文件
- const tmp = decodeURI(href).split('#')
-
- let path = tmp[0]
- if (!path.startsWith('/')) { // 将相对路径转换为绝对路径
- path = join(dirname(filePath || ''), path)
- }
-
- // 打开文件
- switchDoc({
- path,
- name: basename(path),
- repo: fileRepo,
- type: 'file'
- })
-
- // 跳转锚点
- const hash = tmp.slice(1).join('#')
- if (hash) {
- setTimeout(() => {
- const el = document.getElementById(hash) ||
- document.getElementById(encodeURIComponent(hash))
-
- if (el) {
- // 如果是标题的话，也顺便将编辑器滚动到可视区域
- if (hash.startsWith('h-')) {
- el.click()
- }
- el.scrollIntoView()
- }
- }, 50)
- }
-
- return true
- } else if (href && href.startsWith('#')) { // 处理 TOC 跳转
- const el = document.getElementById(href.replace(/^#/, ''))
- if (el) {
- el.scrollIntoView()
- }
- return true
- }
-
- return false
- }
-}
-
-function convertLink (state: StateCore) {
- const tags = ['audio', 'img', 'source', 'video', 'track', 'a']
-
- const { repo, path, name } = state.env.file || {}
- if (!repo || !path || !name) {
- return false
- }
-
- const link = (token: Token) => {
- const attrName = token.tag === 'a' ? 'href' : 'src'
- const attrVal = decodeURIComponent(token.attrGet(attrName) || '')
- if (!attrVal) {
- return
- }
-
- if (/^[^:]*:/.test(attrVal)) { // xxx: : 开头不转换
- return
- }
-
- const basePath = dirname(path)
- const fileName = basename(attrVal)
-
- if (token.tag === 'a') {
- // md 文件不替换
- if (fileName.endsWith('.md')) {
- return
- }
-
- // 路径中有 hash 不替换
- if (attrVal.indexOf('#') > -1) {
- return
- }
- }
-
- token.attrSet(`origin-${attrName}`, attrVal)
-
- if (repo === '__help__') {
- token.attrSet(attrName, `api/help/file?path=${encodeURIComponent(attrVal)}`)
- return
- }
-
- const filePath = join(basePath, attrVal)
- token.attrSet(attrName, `api/attachment/${encodeURIComponent(fileName)}?repo=${repo}&path=${encodeURIComponent(filePath)}`)
- }
-
- const convert = (tokens: Token[]) => {
- tokens.forEach(token => {
- if (tags.includes(token.tag)) {
- link(token)
- }
-
- if (token.children) {
- convert(token.children)
- }
- })
- }
-
- convert(state.tokens)
-
- return true
-}
-
-export default {
- name: 'markdown-link',
- register: (ctx: Ctx) => {
- ctx.registerHook('ON_VIEW_ELEMENT_CLICK', async (e: MouseEvent) => {
- const target = e.target as HTMLElement
-
- const preventEvent = () => {
- e.preventDefault()
- e.stopPropagation()
- return true
- }
-
- if (target.tagName === 'A' || target.parentElement?.tagName === 'A') {
- if (handleLink(target as HTMLAnchorElement)) {
- return preventEvent()
- } else {
- return true
- }
- }
-
- return false
- })
-
- ctx.markdown.registerPlugin(md => {
- md.core.ruler.push('convert_relative_path', convertLink)
- md.renderer.rules.link_open = (tokens, idx, options, _, slf) => {
- if (tokens[idx].attrIndex('target') < 0) {
- tokens[idx].attrPush(['target', '_blank'])
- }
-
- return slf.renderToken(tokens, idx, options)
- }
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-link/index.ts b/src/renderer/plugins/markdown-link/index.ts
new file mode 100644
index 000000000..9a9465567
--- /dev/null
+++ b/src/renderer/plugins/markdown-link/index.ts
@@ -0,0 +1,298 @@
+import StateCore from 'markdown-it/lib/rules_core/state_core'
+import ctx, { Plugin } from '@fe/context'
+import store from '@fe/support/store'
+import { removeQuery } from '@fe/utils'
+import { isElectron, isWindows } from '@fe/support/env'
+import { useToast } from '@fe/support/ui/toast'
+import { DOM_ATTR_NAME, DOM_CLASS_NAME } from '@fe/support/args'
+import { basename, join } from '@fe/utils/path'
+import { getAttachmentURL, openExternal, openPath } from '@fe/services/base'
+import { getRepo } from '@fe/services/repo'
+import { getAvailableCustomEditors } from '@fe/services/editor'
+import { fetchTree } from '@fe/support/api'
+import { isMarkdownFile } from '@share/misc'
+import { getRenderEnv } from '@fe/services/view'
+import { convertResourceState, parseLink } from './lib'
+import workerIndexerUrl from './worker-indexer?worker&url'
+import type { Doc, ParseLinkResult } from '@fe/types'
+
+function getAnchorElement (target: HTMLElement) {
+ let cur: HTMLElement | null = target
+ while (cur && cur.tagName !== 'A' && cur.tagName !== 'ARTICLE') {
+ cur = cur.parentElement
+ }
+
+ return cur?.tagName === 'A' ? cur : null
+}
+
+function handleLink (link: HTMLAnchorElement): boolean {
+ const currentFile = getRenderEnv()?.file || store.state.currentFile
+ if (!currentFile) {
+ return false
+ }
+
+ const href = link.getAttribute('href') || ''
+
+ if (!href.trim()) {
+ useToast().show('warning', 'Link is empty.')
+ return true
+ }
+
+ const _switchDoc = async (parsedLink: ParseLinkResult | null) => {
+ if (parsedLink?.type !== 'internal') {
+ ctx.ui.useToast().show('warning', 'Invalid File Path.')
+ return
+ }
+
+ const file: Doc = parsedLink.path
+ ? { path: parsedLink.path, type: 'file', name: parsedLink.name || basename(parsedLink.path), repo: currentFile.repo }
+ : currentFile
+
+ await ctx.doc.switchDoc(file, { source: 'markdown-link', position: parsedLink.position })
+ }
+
+ const isWikiLink = !!link.getAttribute(DOM_ATTR_NAME.WIKI_LINK)
+ if (!isWikiLink) {
+ const parsedLink = parseLink(currentFile, href, false)
+ if (parsedLink?.type === 'external') {
+ if (/^file:\/\//i.test(parsedLink?.href)) {
+ openPath(decodeURI(parsedLink.href.replace(/^file:\/\//i, '')))
+ return true
+ } else if (/javascript:/i.test(href)) {
+ return false
+ } else {
+ try {
+ if (isElectron) {
+ openExternal(link.href)
+ } else {
+ window.open(link.href)
+ }
+ } catch (error) {
+ console.error(error)
+ useToast().show('warning', 'Failed to open link')
+ }
+
+ return true
+ }
+ } else if (parsedLink?.type === 'internal') {
+ const openFile = () => {
+ const parsedLink = parseLink(currentFile, href, false)
+ const path = (parsedLink && 'path' in parsedLink) ? parsedLink.path : ''
+
+ if (!path) {
+ return true
+ }
+
+ let basePath = (getRepo(currentFile.repo)?.path || '/')
+
+ // net drive path start with '\\' on Windows, so we need to replace '/' to '\\' to prevent `join` lost the first part.
+ if (isWindows) {
+ basePath = basePath.replaceAll('/', '\\')
+ }
+
+ openPath(join(basePath, path))
+ }
+
+ if (link.classList.contains(DOM_CLASS_NAME.MARK_OPEN)) {
+ openFile()
+ return true
+ } else if (
+ (!parsedLink.path && parsedLink.position) || // anchor
+ isMarkdownFile(parsedLink.path) // markdown file
+ ) {
+ _switchDoc(parsedLink)
+ return true
+ } else {
+ const doc: Doc = { path: parsedLink.path, type: 'file', name: basename(parsedLink.path), repo: currentFile.repo }
+
+ getAvailableCustomEditors({ doc }).then(editors => {
+ if (editors.length > 0) {
+ _switchDoc(parsedLink)
+ } else {
+ openFile()
+ }
+ })
+
+ return true
+ }
+ } else {
+ useToast().show('warning', 'Invalid link.')
+ return true
+ }
+ } else {
+ // is Wiki Link
+ if (store.state.currentRepo?.name === currentFile.repo && store.state.tree) {
+ _switchDoc(parseLink(currentFile, href, true, store.state.tree))
+ } else {
+ fetchTree(currentFile.repo, { by: 'mtime', order: 'desc' }).catch(() => []).then(tree => {
+ const parsedLink = parseLink(currentFile, href, true, tree)
+ _switchDoc(parsedLink)
+ })
+ }
+
+ return true
+ }
+}
+
+function convertLink (state: StateCore) {
+ const currentFile = state.env.file || store.state.currentFile
+ return convertResourceState(currentFile, state, getAttachmentURL)
+}
+
+export default {
+ name: 'markdown-link',
+ register: (ctx) => {
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', async ({ node, options }) => {
+ // local image
+ const src = (node as any).src
+ if (src && node.getAttribute(DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ if (options.useRemoteSrcOfLocalImage) {
+ node.setAttribute('src', src)
+ return
+ }
+
+ if (options.inlineLocalImage || options.uploadLocalImage) {
+ try {
+ const originSrc = node.getAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ const res: Response = await ctx.api.fetchHttp(src)
+ const fileName = originSrc ? ctx.utils.path.basename(removeQuery(originSrc)) : 'img'
+ const file = new File(
+ [await res.blob()],
+ fileName,
+ { type: ctx.lib.mime.getType(fileName) || undefined }
+ )
+
+ let url: string | undefined
+ if (options.inlineLocalImage) {
+ url = await ctx.utils.fileToBase64URL(file)
+ } else if (options.uploadLocalImage) {
+ url = await ctx.action.getActionHandler('plugin.image-hosting-picgo.upload')(file)
+ }
+
+ if (url) {
+ node.setAttribute('src', url)
+ node.removeAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ }
+ } catch (error) {
+ console.log(error)
+ }
+ } else {
+ node.setAttribute('src', src)
+ }
+ }
+
+ const originSrc = node.getAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ if (originSrc) {
+ node.setAttribute('src', originSrc)
+ node.removeAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ }
+ })
+
+ ctx.registerHook('VIEW_ELEMENT_CLICK', async ({ e }) => {
+ const anchorTarget = getAnchorElement(e.target)
+
+ if (anchorTarget) {
+ if (handleLink(anchorTarget)) {
+ e.preventDefault()
+ e.stopPropagation()
+ return true
+ } else {
+ return true
+ }
+ }
+
+ return false
+ })
+
+ ctx.registerHook('VIEW_AFTER_REFRESH', () => {
+ ctx.view.getRenderIframe().then(iframe => {
+ // reload all images
+ const images = iframe.contentDocument!.querySelectorAll('img')
+ for (let i = 0; i < images.length; i++) {
+ const img = images[i]
+
+ if (img.getAttribute(DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ if (img.src) {
+ // add timestamp to force reload
+ img.src = img.src.includes('?') ? `${img.src}&_t=${Date.now()}` : `${img.src}?_t=${Date.now()}`
+ }
+ }
+ }
+ })
+ })
+
+ ctx.registerHook('DOC_SWITCH_SKIPPED', ({ opts }) => {
+ if (opts?.position) {
+ ctx.routines.changePosition(opts.position)
+ }
+ })
+
+ ctx.registerHook('DOC_SWITCHED', ({ doc, opts }) => {
+ if (doc && opts?.position) {
+ ctx.routines.changePosition(opts.position)
+ }
+ })
+
+ ctx.markdown.registerPlugin(md => {
+ md.core.ruler.push('convert-relative-path', convertLink)
+ md.renderer.rules.link_open = (tokens, idx, options, _, slf) => {
+ if (tokens[idx].attrIndex('target') < 0) {
+ tokens[idx].attrPush(['target', '_blank'])
+ }
+
+ return slf.renderToken(tokens, idx, options)
+ }
+
+ // skip link validate
+ md.validateLink = () => true
+ })
+
+ ctx.view.tapContextMenus((menus, e) => {
+ const target = e.target as HTMLLinkElement
+ const parent = target.parentElement
+ const link = target.getAttribute('href') || ''
+ const text = target.innerText
+
+ if (
+ target.tagName === 'A' &&
+ parent?.dataset?.sourceLine &&
+ (text === link || text === decodeURI(link)) &&
+ /^http:\/\/|^https:\/\//.test(link)
+ ) {
+ menus.push({
+ id: 'plugin.markdown-link.transform-link',
+ type: 'normal',
+ label: ctx.i18n.t('markdown-link.convert-to-titled-link'),
+ onClick: async () => {
+ try {
+ ctx.ui.useToast().show('info', 'Loading……', 0)
+ const res = await ctx.api.proxyFetch(target.href, { timeout: 10000 }).then(r => r.text())
+ const match = res.match(/]*>([^<]*)<\/title>/si) || []
+ const title = ctx.lib.lodash.unescape(match[1] || '').trim()
+
+ if (!title) {
+ throw new Error('No title')
+ }
+
+ const lineStart = parseInt(parent.getAttribute(DOM_ATTR_NAME.SOURCE_LINE_START) || '0')
+ const lineEnd = parseInt(parent.getAttribute(DOM_ATTR_NAME.SOURCE_LINE_END) || '0') - 1
+
+ const content = ctx.editor.getLinesContent(lineStart, lineEnd)
+ .replace(new RegExp(`(??(?!\\))`, 'i'), `[${title}](${link})`)
+
+ ctx.editor.replaceLines(lineStart, lineEnd, content)
+ ctx.ui.useToast().hide()
+ } catch (error: any) {
+ console.error(error)
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ })
+ }
+ })
+
+ ctx.indexer.importScriptsToWorker(new URL(workerIndexerUrl, import.meta.url))
+
+ return { mdRuleConvertLink: convertLink, htmlHandleLink: handleLink }
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-link/lib.ts b/src/renderer/plugins/markdown-link/lib.ts
new file mode 100644
index 000000000..b7d5aa0a1
--- /dev/null
+++ b/src/renderer/plugins/markdown-link/lib.ts
@@ -0,0 +1,221 @@
+import { basename, dirname, normalizeSep, resolve } from '@fe/utils/path'
+import { isMarkdownFile, MARKDOWN_FILE_EXT } from '@share/misc'
+import { DOM_ATTR_NAME, RESOURCE_TAG_NAMES } from '@fe/support/args'
+import { triggerHook } from '@fe/core/hook'
+import { removeQuery } from '@fe/utils/pure'
+import { isWindows } from '@fe/support/env'
+import type { Token } from 'markdown-it'
+import type StateCore from 'markdown-it/lib/rules_core/state_core'
+import type { Components, Doc, ParseLinkResult, PathItem, PositionState, ResourceTagName } from '@fe/types'
+
+const RE_POS = /:([0-9]+),?([0-9]+)?$/
+const RE_EXTERNAL_LINK = /^[a-zA-Z_+-]{1,}:/
+const RE_VIDEO = /\.(mp4|webm|ogg)$/
+const RE_AUDIO = /\.(mp3|wav|ogg)$/
+const RE_EXTNAME = /^[a-zA-Z0-9_-]{1,10}$/
+
+export function isAnchorToken (token: Token) {
+ return token.tag === 'a'
+}
+
+export function isResourceToken (token: Token) {
+ return RESOURCE_TAG_NAMES.includes(token.tag as ResourceTagName)
+}
+
+export function normalizeExternalLink (link: string) {
+ if (link.startsWith('//')) {
+ return 'https:' + link
+ }
+
+ if (isWindows && /^[a-zA-Z]:[\\/].+/.test(link)) { // windows path
+ return 'file://' + link
+ }
+
+ return link
+}
+
+export function isDataUrl (url: string) {
+ return url.startsWith('data:')
+}
+
+const treeCache = new WeakMap>()
+
+export function getFirstMdMatchPath (tree: Components.Tree.Node[], dir: string, fileName: string): string | null {
+ if (fileName.includes('/')) {
+ return fileName
+ }
+
+ const inDirPath = dir.endsWith('/') ? (dir + fileName) : (dir + '/' + fileName)
+ let cache = treeCache.get(tree)
+
+ if (!cache) {
+ const buildCache = (cache: Map, items: Components.Tree.Node[]) => {
+ // BFS
+
+ const queue: Components.Tree.Node[] = [...items]
+ while (queue.length > 0) {
+ const item = queue.shift()
+ if (!item) continue
+
+ const p = item.path
+ if (item.type === 'file' && isMarkdownFile(p)) {
+ cache.set(p, true)
+
+ // cache the first match
+ if (!cache.has(item.name)) {
+ cache.set(item.name, p)
+ }
+ }
+
+ if (item.children) {
+ queue.push(...item.children)
+ }
+ }
+ }
+
+ cache = new Map()
+ buildCache(cache, tree)
+ treeCache.set(tree, cache)
+ }
+
+ if (cache.has(inDirPath)) { // find in dir
+ return inDirPath
+ } else { // find first match
+ const val = cache.get(fileName)
+ return typeof val === 'string' ? val : null
+ }
+}
+
+export function convertResourceState (currentFile: PathItem, state: StateCore, buildAttachmentUrl?: (file: Doc) => string) {
+ const { repo, path } = currentFile || {}
+ if (!repo || !path) {
+ throw new Error('currentFile is required')
+ }
+
+ const link = (token: Token) => {
+ const attrName = 'src'
+ let attrVal = decodeURIComponent(token.attrGet(attrName) || '')
+ if (!attrVal) {
+ return
+ }
+
+ attrVal = normalizeExternalLink(attrVal)
+
+ if (RE_EXTERNAL_LINK.test(attrVal)) { // external link
+ return
+ }
+
+ const basePath = dirname(path)
+
+ const originAttr = DOM_ATTR_NAME.ORIGIN_SRC
+ const originPath = removeQuery(attrVal).replace(RE_POS, '')
+ const filePath = resolve(basePath, originPath)
+ const fileName = basename(filePath)
+
+ const file: Doc = {
+ type: 'file',
+ repo,
+ path: filePath,
+ name: fileName,
+ }
+
+ if (RE_VIDEO.test(fileName)) {
+ token.tag = 'video'
+ token.type = 'media'
+ } else if (RE_AUDIO.test(fileName)) {
+ token.tag = 'audio'
+ token.type = 'media'
+ token.attrSet('preload', 'none')
+ } else {
+ token.attrSet(DOM_ATTR_NAME.LOCAL_IMAGE, 'true')
+ }
+
+ token.attrSet(DOM_ATTR_NAME.TARGET_PATH, filePath)
+ token.attrSet(DOM_ATTR_NAME.TARGET_REPO, repo)
+ token.attrSet(originAttr, attrVal)
+
+ if (buildAttachmentUrl) {
+ token.attrSet(attrName, buildAttachmentUrl(file))
+ }
+ }
+
+ const convert = (tokens: Token[]) => {
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i]
+ if (isResourceToken(token)) {
+ link(token)
+ }
+
+ if (token.children) {
+ convert(token.children)
+ }
+ }
+ }
+
+ convert(state.tokens)
+
+ return true
+}
+
+export function parseLink (currentFile: PathItem, href: string, isWikiLink: false): ParseLinkResult | null
+export function parseLink (currentFile: PathItem, href: string, isWikiLink: true, tree: Components.Tree.Node[]): ParseLinkResult | null
+export function parseLink (currentFile: PathItem, href: string, isWikiLink: boolean, tree?: Components.Tree.Node[]): ParseLinkResult | null {
+ if (!currentFile) {
+ return null
+ }
+
+ href = href.trim()
+
+ if (!href) {
+ return null
+ }
+
+ href = normalizeExternalLink(href)
+
+ if (RE_EXTERNAL_LINK.test(href)) {
+ return { type: 'external', href }
+ }
+
+ const tmp = decodeURI(href).split('#')
+
+ const parsePathPos = (path: string): {pos: [number, number] | null, path: string} => {
+ const match = path.match(RE_POS)
+ let pos: [number, number] | null = null
+ if (match) {
+ path = path.replace(RE_POS, '')
+ pos = [parseInt(match[1]), match[2] ? parseInt(match[2]) : 1]
+ }
+
+ return { pos, path }
+ }
+
+ let { path, pos } = parsePathPos(normalizeSep(tmp[0]))
+ const baseDir = dirname(currentFile.path)
+ path = path.trim()
+
+ if (path) {
+ if (isWikiLink && tree) {
+ path = path.replace(/:/g, '/') // replace all ':' to '/'
+
+ const lastDotPos = path.lastIndexOf('.')
+ const ext = lastDotPos > -1 ? path.slice(lastDotPos + 1) : ''
+ const fileName = RE_EXTNAME.test(ext) ? path : path += MARKDOWN_FILE_EXT
+
+ if (isMarkdownFile(fileName)) {
+ path = getFirstMdMatchPath(tree, baseDir, fileName) || path
+ }
+ }
+
+ path = resolve(baseDir, path)
+ }
+
+ const hash = tmp.slice(1).join('#')
+ const position: PositionState | null = pos ? { line: pos[0], column: pos[1] } : hash ? { anchor: hash } : null
+
+ const name = basename(path)
+ const result: ParseLinkResult = { type: 'internal', path, name, position }
+
+ triggerHook('AFTER_PARSE_LINK', { params: { currentFile, href, isWikiLink, tree }, result })
+
+ return result
+}
diff --git a/src/renderer/plugins/markdown-link/worker-indexer.ts b/src/renderer/plugins/markdown-link/worker-indexer.ts
new file mode 100644
index 000000000..d3af82aaf
--- /dev/null
+++ b/src/renderer/plugins/markdown-link/worker-indexer.ts
@@ -0,0 +1,15 @@
+import { convertResourceState } from './lib'
+import type { IndexerWorkerCtx } from '@fe/others/indexer-worker'
+import type StateCore from 'markdown-it/lib/rules_core/state_core'
+
+const ctx: IndexerWorkerCtx = self.ctx
+
+ctx.markdown.use(md => {
+ md.core.ruler.push('convert-relative-path', (state: StateCore) => {
+ const currentFile = state.env?.file
+ return convertResourceState(currentFile, state)
+ })
+
+ // skip link validate
+ md.validateLink = () => true
+})
diff --git a/src/renderer/plugins/markdown-luckysheet.ts b/src/renderer/plugins/markdown-luckysheet.ts
index 475b08210..7ee70ef8b 100644
--- a/src/renderer/plugins/markdown-luckysheet.ts
+++ b/src/renderer/plugins/markdown-luckysheet.ts
@@ -1,302 +1,33 @@
-import { defineComponent, h, ref, watch } from 'vue'
-
+import { h } from 'vue'
import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { getLogger } from '@fe/utils'
-import { Doc } from '@fe/support/types'
-import { useModal } from '@fe/support/modal'
-import { useToast } from '@fe/support/toast'
-import { dirname, join } from '@fe/utils/path'
-import env from '@fe/utils/env'
+import { Plugin } from '@fe/context'
import store from '@fe/support/store'
-import * as api from '@fe/support/api'
-import { refreshTree } from '@fe/context/tree'
-import { buildSrc, IFrame } from '@fe/context/embed'
-import Mask from '@fe/components/Mask.vue'
-
-const logger = getLogger('plugin-markdown-luckysheet')
-
-const fileExt = '.luckysheet'
-
-function buildSrcdoc (repo: string, path: string, full: boolean) {
- const options = { container: 'lucky-sheet', lang: 'zh', showtoolbarConfig: { print: false } }
- let onload = ''
-
- if (full) {
- onload = `
- const btn = document.createElement('button');
- btn.style = 'border: 0; background: #666; cursor: pointer; margin-left: 10px; color: #fff; padding: 4px 8px;';
- btn.innerText = '保存'
- btn.onclick = save
- document.querySelector('.luckysheet_info_detail .sheet-name').after(btn)
- document.querySelector('.luckysheet_info_detail .luckysheet_info_detail_update').innerText = '${path}'
- setStatus('加载完毕')
-
- ${env.isElectron
- ? `
- let closeWindow = false
- const remote = window.nodeRequire && window.nodeRequire('electron').remote
- window.onbeforeunload = evt => {
- if (saved() || closeWindow) return null
-
- if (!remote) {
- return true
- }
-
- evt.returnValue = true
-
- setTimeout(() => {
- let result = remote.dialog.showMessageBoxSync({
- type: 'question',
- cancelId: 1,
- message: '文档未保存，确定要关闭吗？',
- buttons: ['关闭', '取消']
- })
-
- if (result === 0) {
- closeWindow = true
- remote.getCurrentWindow().close()
- }
- })
- }` : 'window.onbeforeunload = () => saved() ? null : true'
- }
-
- window.addEventListener('keydown', e => {
- const isMacOS = /macintosh|mac os x/i.test(navigator.userAgent)
- const ctrl = isMacOS ? e.metaKey : e.ctrlKey
- if (ctrl && e.code === 'KeyS') {
- save()
- e.stopPropagation()
- e.preventDefault()
- }
- })
- `
- Object.assign(options, {})
- } else {
- Object.assign(options, {
- showtoolbar: false,
- showinfobar: false,
- allowEdit: false,
- showsheetbarConfig: {
- add: false,
- menu: false,
- sheet: true
- },
- sheetRightClickConfig: {
- delete: false,
- copy: false,
- rename: false,
- color: false,
- hide: false,
- move: false,
- },
- })
- }
-
- return `
-
-
-
-
-
-
-
-
-
- `
-}
-
-const LuckyComponent = defineComponent({
- name: 'lucky-sheet',
- props: {
- repo: String,
- path: String
- },
- setup (props) {
- logger.debug('setup', props)
- const srcdoc = ref('')
- const refIFrame = ref()
- const refFullIFrame = ref()
- const fullScreen = ref(false)
-
- const update = () => {
- srcdoc.value = buildSrcdoc(props.repo!, props.path!, false)
- }
-
- const reload = () => {
- refIFrame.value.reload()
- }
+const MarkdownItPlugin = (md: Markdown) => {
+ const extensionId = '@yank-note/extension-luckysheet'
- const open = () => {
- fullScreen.value = true
- }
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
- const close = async () => {
- try {
- refFullIFrame.value.close()
- fullScreen.value = false
- } catch {
- if (await useModal().confirm({ title: '未保存文件', content: '是否要关闭？' })) {
- fullScreen.value = false
- }
- }
+ const render = () => {
+ if (!getInitialized()) {
+ return null
}
- watch(props, update, { immediate: true })
-
- const button = (text: string, onClick: any) => h('button', {
- style: 'margin-left: 5px;font-size: 14px;background: #cacaca; border: 0; padding: 0 6px; color: #2c2b2b; cursor: pointer; border-radius: 2px; transition: all .1s ease-in-out; line-height: 24px;',
- onClick
- }, text)
-
- const buildIFrame = (full: boolean) => h(IFrame, {
- ref: full ? refFullIFrame : refIFrame,
- html: buildSrcdoc(props.repo!, props.path!, full),
- debounce: 1000,
- iframeProps: {
- class: 'lucky-sheet',
- style: 'margin: 0;display:block;height: ' + (full ? 'calc(100vh - 30px)' : '500px'),
- width: '100%'
- }
- })
-
- return () => [
- fullScreen.value && h(Mask, {
- show: true,
- maskCloseable: false,
- escCloseable: false,
- style: { paddingTop: '30px' }
- }, [
- h(
- 'div',
- {
- class: 'no-print',
- style: 'position: absolute; right: 15px; margin-top: 15px; z-index: 1;'
- },
- button('关闭', close),
- ),
- buildIFrame(true),
- ]),
-
- h('div', { class: 'lucky-sheet-wrapper reduce-brightness', style: 'position: relative' }, [
- h(
- 'div',
- {
- class: 'no-print',
- style: 'position: absolute; right: 15px; top: 3px; z-index: 1;'
- },
- [
- button('编辑', open),
- button('重载', reload),
- button('新窗口编辑', () => {
- const html = buildSrcdoc(props.repo!, props.path!, true)
- env.openWindow(buildSrc(html, '编辑表格', false), '_blank', { alwaysOnTop: false })
- }),
- ]
- ),
- buildIFrame(false)
- ])
- ]
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'Luckyseet'))
+ ))
}
-})
-const MarkdownItPlugin = (md: Markdown) => {
const linkTemp = md.renderer.rules.link_open!.bind(md.renderer.rules)
md.renderer.rules.link_open = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return linkTemp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
if (token.attrGet('link-type') !== 'luckysheet') {
@@ -308,102 +39,17 @@ const MarkdownItPlugin = (md: Markdown) => {
return linkTemp(tokens, idx, options, env, slf)
}
- const url = token.attrGet('origin-href')
+ const url = token.attrGet('href')
if (!url || url.includes(':')) {
return linkTemp(tokens, idx, options, env, slf)
}
- const path = join(dirname(currentFile.path), url)
-
const nextToken = tokens[idx + 1]
if (nextToken && nextToken.type === 'text') {
nextToken.content = ''
}
- return h(LuckyComponent, { repo: currentFile.repo, path }) as any
- }
-}
-
-async function createLuckysheet (node: Doc) {
- const currentPath = node.path
-
- let filename = await useModal().input({
- title: '创建 Luckysheet 文件',
- hint: '文件路径',
- content: '当前路径：' + currentPath,
- value: 'new-sheet' + fileExt,
- select: true
- })
-
- if (!filename) {
- return
- }
-
- if (!filename.endsWith(fileExt)) {
- filename = filename.replace(/\/$/, '') + fileExt
- }
-
- const path = join(currentPath, filename).replace(/^\//, '')
-
- if (!path) {
- throw new Error('需要传入文件路径')
- }
-
- const file: Doc = { repo: node.repo, path: path, type: 'file', name: '', contentHash: 'new' }
-
- if (typeof file.content !== 'string') {
- file.content = JSON.stringify([{
- name: 'Sheet1',
- color: '',
- status: 1,
- order: 0,
- data: Array(20).fill(Array(14).fill(null)),
- config: {
- merge: {},
- rowlen: {},
- rowhidden: {}
- },
- index: 0,
- jfgird_select_save: [],
- luckysheet_select_save: [{
- row: [0, 0],
- column: [0, 0],
- row_focus: 0,
- column_focus: 0,
- left: 0,
- width: 73,
- top: 0,
- height: 19,
- left_move: 0,
- width_move: 73,
- top_move: 0,
- height_move: 19
- }],
- visibledatarow: [],
- visibledatacolumn: [],
- ch_width: 4560,
- rh_height: 1760,
- luckysheet_selection_range: [],
- zoomRatio: 1,
- scrollLeft: 0,
- scrollTop: 0,
- calcChain: [],
- filter_select: null,
- filter: null,
- luckysheet_conditionformat_save: [],
- luckysheet_alternateformat_save: [],
- dataVerification: {},
- hyperlink: {},
- celldata: []
- }])
- }
-
- try {
- await api.writeFile(file, file.content)
- refreshTree()
- } catch (error) {
- useToast().show('warning', error.message)
- console.error(error)
+ return render() as any
}
}
@@ -411,31 +57,13 @@ export default {
name: 'markdown-luckysheet',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin)
- ctx.registerHook('ON_TREE_NODE_SELECT', async (item: Doc) => {
- if (item.path.toLowerCase().endsWith(fileExt)) {
- const srcdoc = buildSrcdoc(item.repo, item.path, true)
- env.openWindow(buildSrc(srcdoc, '编辑表格', false), '_blank', { alwaysOnTop: false })
-
- return true
- }
-
- return false
- })
- ctx.tree.registerContextMenu((items, node) => {
- if (node.type === 'dir') {
- items.push(
- { type: 'separator' },
- {
- id: 'create-luckysheet',
- type: 'normal',
- label: '创建 Luckysheet 文件',
- onClick: () => createLuckysheet(node)
- }
- )
- }
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- return items
+ items.push(
+ { language: 'markdown', label: '/ []() Luckysheet Link', insertText: '[${2:Luckysheet}]($1){link-type="luckysheet"}', block: true },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-macro.ts b/src/renderer/plugins/markdown-macro.ts
new file mode 100644
index 000000000..c6c0f3f79
--- /dev/null
+++ b/src/renderer/plugins/markdown-macro.ts
@@ -0,0 +1,494 @@
+import { escapeRegExp, merge, omit } from 'lodash-es'
+import frontMatter from 'front-matter'
+import type { Plugin } from '@fe/context'
+import type { BuildInSettings, Doc } from '@fe/types'
+import type { MenuItem } from '@fe/services/status-bar'
+import { render } from '@fe/services/view'
+import { t } from '@fe/services/i18n'
+import { readFile } from '@fe/support/api'
+import { getLogger, md5 } from '@fe/utils'
+import { basename, dirname, resolve } from '@fe/utils/path'
+import { getPurchased } from '@fe/others/premium'
+import { isPlain } from '@fe/services/document'
+import ctx from '@fe/context'
+
+type Result = { __macroResult: true, vars?: Record, value: string }
+type CacheItem = {
+ $include?: Record
+ $define: Record
+} & Record>
+
+const logger = getLogger('plugin-macro')
+const debounceToast = ctx.lib.lodash.debounce((...args: [any, any]) => ctx.ui.useToast().show(...args), 300)
+const magicNewline = '--yn-macro-new-line--'
+
+const AsyncFunction = Object.getPrototypeOf(async () => 0).constructor
+let globalMacroReplacement: Record = {}
+
+const globalVars = {
+ $export: exportVar,
+ $afterMacro: afterMacro,
+ $ctx: ctx,
+ $noop: noop,
+}
+
+function createSeq () {
+ const counters: Record = {}
+ return function (str = '') {
+ if (!counters[str]) {
+ counters[str] = 0
+ }
+ counters[str]++
+ return `${str}${counters[str]}`
+ }
+}
+
+function lineCount (str: string) {
+ let s = 1
+ const len = str.length
+
+ for (let i = 0; i < len; i++) {
+ if (str.charCodeAt(i) === 0x0A) {
+ s++
+ }
+ }
+
+ return s
+}
+
+function wrapResult (result: any) {
+ let value = result
+ let res = result
+ if (result.__macroResult) {
+ value = result.value
+ } else {
+ res = { __macroResult: true, value: '' + value }
+ }
+
+ if (
+ value === null ||
+ typeof value === 'function' ||
+ typeof value === 'symbol' ||
+ typeof value === 'undefined' ||
+ (typeof value === 'object')
+ ) {
+ throw new Error('Macro result type error.')
+ }
+
+ return res
+}
+
+function macro (exp: string, vars: Record): Result | Promise {
+ logger.debug('macro', exp)
+
+ exp = exp.replaceAll(magicNewline, '\n')
+
+ const FunctionConstructor = exp.startsWith('await') ? AsyncFunction : Function
+ const fun = new FunctionConstructor('vars', `with (vars) { return (${exp}); }`)
+
+ let result = fun(vars)
+
+ if (!(result instanceof Promise)) {
+ return wrapResult(result)
+ }
+
+ result = result.then(wrapResult)
+
+ return result
+}
+
+function transform (
+ src: string,
+ vars: Record,
+ options: {
+ autoRerender: boolean,
+ purchased: boolean,
+ cache: CacheItem,
+ callback?: (result: Result | Promise, match: string, matchPos: number) => void
+ },
+): { value: string, vars: Record } {
+ let _vars: Record = merge({ define: { ...globalMacroReplacement } }, vars)
+ const define = { ...options.cache.$define, ..._vars.define }
+ _vars.define = define
+ const keys = Object.keys(define)
+ if (keys.length) {
+ const reg = new RegExp(keys.filter(Boolean).map(escapeRegExp).join('|'), 'g')
+ src = src.replace(reg, match => {
+ const val = define[match]
+ // only support single line macro expression
+ if (typeof val === 'string' && /^\s*\[=.+?=\]\s*$/s.test(val)) {
+ // single line expression
+ return val.trim().replaceAll('\n', magicNewline)
+ } else {
+ match = match.replace(/\n|'/, '\\$&')
+ return `[= define['${match}'] =]`
+ }
+ })
+ }
+
+ const value = src.replace(/\[=.+?=\]/gs, (match, matchPos) => {
+ try {
+ const exp = match
+ .substring(2, match.length - 2)
+ .trim()
+ .replace(/=\\\]|\[\\=/g, x => x.replace('\\', ''))
+
+ const id = md5(exp)
+
+ let result: Result | Promise
+ if (options.purchased) {
+ if (options.cache[id]) {
+ result = options.cache[id]
+ } else {
+ result = macro(exp, _vars)
+ if (result instanceof Promise) {
+ options.cache[id] = result
+ .catch(() => ({ __macroResult: true, value: match } as Result))
+ .then(res => {
+ options.cache[id] = res
+ options.autoRerender && render()
+ return res
+ })
+ }
+ }
+ } else {
+ result = { __macroResult: true, value: t('premium.need-purchase', 'Macro') + `, ${t('premium.buy-license')} ` }
+ }
+
+ options.callback?.(result, match, matchPos)
+
+ if (result instanceof Promise) {
+ return 'running...'
+ }
+
+ if (result.vars) {
+ _vars = merge({}, result.vars, _vars)
+ }
+
+ return result.value
+ } catch {}
+
+ return match.replaceAll(magicNewline, '\n')
+ })
+
+ return { value, vars: _vars }
+}
+
+function exportVar (key: string, val: any): Result {
+ return { __macroResult: true, vars: { [key]: val }, value: '' }
+}
+
+function afterMacro (fn: (src: string) => string): Result {
+ return { __macroResult: true, vars: { $__hook_after_macro: fn }, value: '' }
+}
+
+// do nothing, text placeholder
+function noop () {
+ return { __macroResult: true, value: '' }
+}
+
+async function include (
+ options: {
+ belongDoc: Doc | undefined | null
+ purchased: boolean,
+ cache: CacheItem,
+ count: number,
+ vars: Record
+ },
+ path: string,
+ trim = false
+): Promise {
+ const { belongDoc } = options
+
+ if (!belongDoc) {
+ throw new Error('Current document is null')
+ }
+
+ if (options.count >= 3) {
+ return { __macroResult: true, value: 'Error: $include maximum call stack size exceeded [3]' }
+ }
+
+ if (!isPlain({ type: 'file', path })) {
+ return { __macroResult: true, value: 'Error: $include path is not a plain file' }
+ }
+
+ try {
+ const absolutePath = resolve(dirname(belongDoc.path), path)
+ const file: Doc = { type: 'file', name: basename(absolutePath), repo: belongDoc.repo, path: absolutePath }
+ const { content } = await readFile(file)
+ const fm = frontMatter(content)
+
+ // merge front-matter attributes to current document vars.
+ const vars: Record = merge(
+ {},
+ (fm.attributes && typeof fm.attributes === 'object') ? fm.attributes : {},
+ options.vars
+ )
+
+ vars.$include = include.bind(null, { ...options, belongDoc: file, count: options.count + 1, vars })
+ vars.$_doc = {
+ basename: file.name ? file.name.substring(0, file.name.lastIndexOf('.')) : '',
+ ...ctx.lib.lodash.pick(file, 'name', 'repo', 'path', 'content', 'status')
+ }
+
+ const cache = options.cache
+ if (options.count === 0 && !options.cache.$include) {
+ cache.$include = {}
+ }
+
+ const cacheKey = '' + options.count + file.repo + file.path
+ if (!cache.$include![cacheKey]) {
+ cache.$include![cacheKey] = { $define: {} } as CacheItem
+ }
+
+ const body = trim ? fm.body.trim() : fm.body
+
+ const tasks: Promise[] = []
+ let result = transform(
+ body,
+ vars,
+ {
+ ...options,
+ cache: cache.$include![cacheKey],
+ autoRerender: false,
+ callback: res => {
+ if (res instanceof Promise) {
+ tasks.push(res.then(x => {
+ cache.$include![cacheKey].$define = { ...x.vars?.define }
+ return x
+ }))
+ }
+ }
+ }
+ )
+
+ if (tasks.length > 0) {
+ await Promise.allSettled(tasks)
+
+ // get final result
+ result = transform(
+ body,
+ vars,
+ {
+ ...options,
+ cache: cache.$include![cacheKey],
+ autoRerender: false,
+ }
+ )
+ }
+
+ cache.$define = { ...result.vars.define }
+
+ return { __macroResult: true, vars: omit(result.vars, '$include', '$_doc'), value: result.value }
+ } catch (error: any) {
+ return error.message
+ }
+}
+
+function hookAfter (body: string, vars: Record) {
+ if (vars.$__hook_after_macro && typeof vars.$__hook_after_macro === 'function') {
+ try {
+ return vars.$__hook_after_macro(body)
+ } catch (error) {
+ debounceToast('warning', `[$afterMacro]: ${error}`)
+ return body
+ }
+ }
+
+ return body
+}
+
+export default {
+ name: 'markdown-macro',
+ register: ctx => {
+ ctx.markdown.registerPlugin(md => {
+ md.core.ruler.after('normalize', 'after_normalize', (state) => {
+ const env = state.env || {}
+ const file = env.file || {}
+
+ if (!env.attributes || !env.attributes.enableMacro || env.safeMode) {
+ return false
+ }
+
+ const cache = ctx.renderer.getRenderCache('plugin-macro', 'cache', { $define: {} } as CacheItem)
+
+ const options = {
+ purchased: getPurchased() || file.repo === ctx.args.HELP_REPO_NAME,
+ cache,
+ autoRerender: true,
+ }
+
+ const vars: Record = { ...globalVars, ...env.attributes }
+
+ vars.$include = include.bind(null, { ...options, belongDoc: file, count: 0, vars })
+ vars.$seq = createSeq()
+ vars.$doc = {
+ basename: file.name ? file.name.substring(0, file.name.lastIndexOf('.')) : '',
+ ...ctx.lib.lodash.pick(env.file, 'name', 'repo', 'path', 'content', 'status')
+ }
+
+ if (!env.macroLines) {
+ env.macroLines = []
+ }
+
+ let lineOffset = 0
+ let posOffset = 0
+
+ const bodyBeginPos = env.bodyBeginPos || 0
+ const head = state.src.substring(0, bodyBeginPos)
+ const body = state.src.substring(bodyBeginPos)
+
+ const result = transform(body, vars, {
+ ...options,
+ callback: (result, match, matchPos) => {
+ if (result instanceof Promise) {
+ return
+ }
+
+ const resultStr = result.value
+ const matchLine = lineCount(match)
+ const resultLine = lineCount(resultStr)
+
+ if (resultLine !== matchLine) {
+ const currentLineOffset = (matchLine - resultLine)
+ const currentPosOffset = (match.length - resultStr.length)
+ lineOffset += currentLineOffset
+ posOffset += currentPosOffset
+ env.macroLines.push({
+ matchPos,
+ matchLine,
+ resultLine,
+ lineOffset,
+ posOffset,
+ currentPosOffset,
+ currentLineOffset,
+ matchLength: match.length,
+ resultLength: resultStr.length,
+ })
+ }
+ }
+ })
+
+ state.src = head + hookAfter(result.value, result.vars)
+ state.env.originSource = state.env.source
+ state.env.source = state.src
+
+ return false
+ })
+ })
+
+ ctx.registerHook('STARTUP', () => {
+ ctx.statusBar.tapMenus(menus => {
+ const list = menus['status-bar-tool']?.list
+ if (list) {
+ const id = 'plugin.markdown-macro.copy-markdown'
+ const env = ctx.view.getRenderEnv()
+ const menu: MenuItem = {
+ id,
+ type: 'normal',
+ hidden: !(env?.attributes?.enableMacro) || env.safeMode,
+ title: ctx.i18n.t('status-bar.tool.macro-copy-markdown'),
+ onClick: () => {
+ ctx.utils.copyText(ctx.view.getRenderEnv()?.source)
+ }
+ }
+
+ const item = list.find(x => x.type === 'normal' && x.id === id)
+ if (item) {
+ Object.assign(item, menu)
+ } else {
+ list.push(menu)
+ }
+ }
+ })
+ })
+
+ ctx.registerHook('VIEW_RENDERED', () => {
+ ctx.statusBar.refreshMenu()
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ [= Macro', insertText: '[= ${1:1+1} =]' },
+ { language: 'markdown', label: '/ [= Macro $include', insertText: '[= \\$include(\'$1\') =]' },
+ { language: 'markdown', label: '/ [= Macro $afterMacro', insertText: '[= \\$afterMacro(src => { \n return src.toUpperCase(); \n}) =]' },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/\[=/, { token: 'keyword', next: '@monacoEnd', nextEmbedded: 'text/javascript' }],
+ )
+
+ mdLanguage.tokenizer.monacoEnd = [
+ [/=\]/, { token: 'keyword', next: '@pop', nextEmbedded: '@pop' }]
+ ]
+ })
+
+ ctx.setting.changeSchema(schema => {
+ schema.groups.push({ label: 'T_setting-panel.tabs.macros', value: 'macros' })
+ schema.properties.macros = {
+ defaultValue: [],
+ type: 'array',
+ title: 'T_setting-panel.schema.repos.repos',
+ format: 'table',
+ group: 'macros',
+ items: {
+ type: 'object',
+ title: 'T_setting-panel.schema.macros.macros',
+ properties: {
+ match: {
+ type: 'string',
+ title: 'T_setting-panel.schema.macros.match',
+ defaultValue: '',
+ maxLength: 50,
+ options: {
+ inputAttributes: { placeholder: 'T_setting-panel.schema.macros.match-placeholder' }
+ },
+ },
+ replace: {
+ type: 'string',
+ title: 'T_setting-panel.schema.macros.replace',
+ defaultValue: '',
+ format: 'textarea',
+ options: {
+ inputAttributes: {
+ placeholder: 'T_setting-panel.schema.macros.replace-placeholder',
+ style: 'height: auto; resize: vertical; min-height: 37px;',
+ rows: 1,
+ }
+ },
+ }
+ } as any
+ },
+ }
+ })
+
+ ctx.registerHook('SETTING_BEFORE_WRITE', ({ settings }) => {
+ if (settings.macros && Array.isArray(settings.macros)) {
+ settings.macros = settings.macros.filter(x => x.match && x.replace)
+ }
+ })
+
+ function buildGlobalMacroReplacement (settings: BuildInSettings) {
+ const macros = settings.macros || []
+ globalMacroReplacement = {}
+ macros.forEach(x => {
+ globalMacroReplacement[x.match] = x.replace
+ })
+ }
+
+ ctx.registerHook('SETTING_FETCHED', ({ settings }) => {
+ buildGlobalMacroReplacement(settings)
+ }, true)
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys, settings }) => {
+ if (changedKeys.includes('macros')) {
+ buildGlobalMacroReplacement(settings)
+ ctx.view.render()
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-mermaid.ts b/src/renderer/plugins/markdown-mermaid.ts
index b7c4a94b8..d5341e976 100644
--- a/src/renderer/plugins/markdown-mermaid.ts
+++ b/src/renderer/plugins/markdown-mermaid.ts
@@ -1,30 +1,37 @@
-import Markdown from 'markdown-it'
-import mermaid from 'mermaid/dist/mermaid.js'
-import { Plugin } from '@fe/context/plugin'
+import type Markdown from 'markdown-it'
import { h } from 'vue'
-
-const mermaidChart: any = (code: string) => {
- try {
- return h('div', { key: code, class: 'mermaid reduce-brightness' }, code)
- } catch ({ str }) {
- return h('pre', str)
- }
-}
+import type { Plugin } from '@fe/context'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+import { t } from '@fe/services/i18n'
const MermaidPlugin = (md: Markdown) => {
- mermaid.initialize({})
+ const extensionId = '@yank-note/extension-mermaid'
+
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
+
+ const render = () => {
+ if (!getInitialized()) {
+ return null
+ }
+
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'Mermaid'))
+ ))
+ }
const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return temp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
- const code = token.content.trim()
if (token.info === 'mermaid') {
- return mermaidChart(code)
- }
- const firstLine = code.split(/\n/)[0].trim()
- if (firstLine === 'gantt' || firstLine === 'sequenceDiagram' || firstLine.match(/^graph (?:TB|BT|RL|LR|TD);?$/)) {
- return mermaidChart(code)
+ return render() as any
}
+
return temp(tokens, idx, options, env, slf)
}
}
@@ -32,12 +39,14 @@ const MermaidPlugin = (md: Markdown) => {
export default {
name: 'markdown-mermaid',
register: ctx => {
- ctx.theme.addStyles(`
- .markdown-view .markdown-body .mermaid {
- background: #fff;
- }
- `)
ctx.markdown.registerPlugin(MermaidPlugin)
- ctx.registerHook('ON_VIEW_RENDERED', () => mermaid.init('.mermaid'))
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` Mermaid', insertText: '```mermaid\ngraph LR\n${1:A[Hard] --> |Text| B(Round)}\n```\n', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-mind-map.ts b/src/renderer/plugins/markdown-mind-map.ts
index cc6eb52b3..ad301ad96 100644
--- a/src/renderer/plugins/markdown-mind-map.ts
+++ b/src/renderer/plugins/markdown-mind-map.ts
@@ -1,16 +1,206 @@
-import { defineComponent, h, onMounted, ref, watch } from 'vue'
+import { defineComponent, h, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { debounce } from 'lodash-es'
import Renderer from 'markdown-it/lib/renderer'
-import { Plugin } from '@fe/context/plugin'
-import crypto from '@fe/utils/crypto'
-import { dataURItoBlobLink } from '@fe/utils'
-import env from '@fe/utils/env'
-import storage from '@fe/utils/storage'
-import { buildSrc } from '@fe/context/embed'
+import { Plugin } from '@fe/context'
+import { downloadDataURL, getLogger, strToBase64, waitCondition } from '@fe/utils'
+import { openWindow } from '@fe/support/env'
+import * as storage from '@fe/utils/storage'
+import { buildSrc } from '@fe/support/embed'
+import store from '@fe/support/store'
+import { registerHook, removeHook } from '@fe/core/hook'
+import { t } from '@fe/services/i18n'
+import { getRenderIframe } from '@fe/services/view'
+import { DOM_ATTR_NAME, DOM_CLASS_NAME } from '@fe/support/args'
+import type { ExportType } from '@fe/types'
+
+const logger = getLogger('markdown-mind-map')
const layoutStorageKey = 'mind-map-layout'
let links = ''
+let mindMapId = 0
+const instances = new Map()
+let window: any // render iframe content window
+let document: any // render iframe content document
+
+async function processRenderWindow () {
+ window = (await getRenderIframe()).contentWindow!
+ document = window.document
+
+ // kityminder has memory leak at CustomEvent, make CustomEvent readonly
+ const CustomEvent = window.CustomEvent
+ Object.defineProperty(window, 'CustomEvent', {
+ get: () => CustomEvent,
+ set: () => undefined
+ })
+
+ Object.defineProperty(window, 'kity', {
+ get: () => {
+ logger.debug('new kity')
+ return window.kityM()
+ },
+ })
+
+ Object.defineProperty(window, 'kityminder', {
+ get: () => {
+ logger.debug('new kityminder')
+ return window.kityminderM && window.kityminderM()
+ },
+ })
+}
+
+processRenderWindow()
+
+async function newMinder () {
+ await waitCondition(() => !!(window.kityminder?.Minder))
+
+ // hack addEventListener, fix memory leak.
+ const realAddEventListener = window.addEventListener.bind(window)
+ const events: {type: string, listener: any}[] = []
+ window.addEventListener = (type: string, listener: any) => {
+ logger.debug('hack addEventListener', type)
+ events.push({ type, listener })
+ realAddEventListener(type, listener)
+ }
+
+ const kityminder = window.kityminder
+ const km = new kityminder.Minder()
+
+ // restore addEventListener
+ window.addEventListener = realAddEventListener
+
+ // fix bug: origin enableAnimation has bug not work.
+ km.enableAnimation = function () {
+ km.setOption('enableAnimation', true)
+ km.setOption('layoutAnimationDuration', 300)
+ km.setOption('viewAnimationDuration', 100)
+ km.setOption('zoomAnimationDuration', 300)
+ }
+
+ const paperEvent = 'click dblclick mousedown contextmenu mouseup mousemove mouseover mousewheel DOMMouseScroll touchstart touchmove touchend dragenter dragleave drop'
+
+ const firePharse = km._firePharse.bind(km)
+ km._bindEvents = function () {
+ this._paper.on(paperEvent, firePharse)
+ window.addEventListener('resize', firePharse)
+ events.push({ type: 'resize', listener: firePharse })
+ }
+
+ const camera = km._commands.camera.execute
+ km._commands.camera.execute = function (km: any, focusNode: any) {
+ if (km._status === 'normal') {
+ return
+ }
+
+ if (focusNode) {
+ camera.call(this, km, focusNode)
+ return
+ }
+
+ // eslint-disable-next-line no-proto
+ const Point = km.getRoot().getVertexIn().__proto__.constructor
+
+ const tpl = km.getTemplate()
+
+ if (['right', 'fish-bone'].includes(tpl)) {
+ const viewport = km.getPaper().getViewPort()
+ const x = viewport.center.x - viewport.center.x / viewport.zoom + 20 / viewport.zoom
+ const y = viewport.center.y + 10 / viewport.zoom
+ const duration = km.getOption('viewAnimationDuration')
+ km._viewDragger.moveTo(new Point(x, y), duration)
+ } else if (['structure', 'filetree'].includes(tpl)) {
+ const viewport = km.getPaper().getViewPort()
+ const x = viewport.center.x
+ const y = viewport.center.y - viewport.center.y / viewport.zoom + 40 / viewport.zoom
+ const duration = km.getOption('viewAnimationDuration')
+ km._viewDragger.moveTo(new Point(x, y), duration)
+ } else {
+ camera.call(this, km)
+ }
+ }
+
+ // disable mouseup event listening
+ km._modules.Select.init = () => 0
+
+ // fix bug: origin dispose has bug not work.
+ km.viewer.dispose = function () {
+ try {
+ document.removeEventListener('keydown', this.hotkeyHandler)
+ this.close()
+ } catch {}
+ }
+
+ // fix bug: https://github.com/fex-team/kityminder-editor/issues/704
+ km.clearSelect = function () {
+ paperEvent.split(' ').forEach(type => this._paper.off(type, firePharse))
+ km.viewer.dispose()
+ events.forEach(({ type, listener }) => {
+ window.removeEventListener(type, listener)
+ })
+ }
+
+ const kmDestroy = km.destroy.bind(km)
+ km.destroy = function () {
+ km._bindEvents = () => 0
+ kmDestroy()
+ }
+
+ // hack, avoid KM editor auto focus.
+ km.focus = () => 0
+
+ km._setTemplate = km.setTemplate
+
+ const importNode = km.importNode.bind(km)
+ km.importNode = function (node: any, json: any) {
+ if (json && json.data && json.data.text) {
+ json.data.text = (json.data.text as string).replace(/^\[(\d+)\]\s*/, (match, $1) => {
+ const num = parseInt($1)
+ if (num > 0) {
+ json.data.priority = num
+ return ''
+ }
+
+ return match
+ })
+ }
+
+ return importNode(node, json)
+ }
+
+ const priorityRender = km._modules.PriorityModule.renderers.left
+ const priorityIconCreate = priorityRender.prototype.create
+ priorityRender.prototype.create = () => {
+ const icon = priorityIconCreate()
+ const setValue = icon.setValue.bind(icon)
+ icon.setValue = function (val: number) {
+ this.mask.fill('#A3A3A3')
+ this.back.fill('#515151')
+ setValue(val)
+ }
+
+ return icon
+ }
+
+ km.disableAnimationAwhile = async (fn: Function) => {
+ // hack for avoid auto set template
+ km.setTemplate = () => 0
+ km.disableAnimation()
+ await fn()
+ km.enableAnimation()
+ // recover setTemplate
+ km.setTemplate = km._setTemplate
+ }
+
+ const importJson = km.importJson.bind(km)
+ km.importJson = function (json: any) {
+ if (json) {
+ importJson(json)
+ }
+ }
+
+ return km
+}
+
const buildSrcdoc = (json: string, btns: string) => {
return `
${links}
@@ -19,6 +209,16 @@ const buildSrcdoc = (json: string, btns: string) => {
margin: 0;
padding: 0;
height: 100%;
+ background: #fff;
+ }
+
+ .mind-map-action {
+ position: absolute;
+ right: 10px;
+ top: 3px;
+ z-index: 1;
+ text-align: right;
+ background: transparent;
}
#minder-view {
@@ -65,32 +265,21 @@ const buildSrcdoc = (json: string, btns: string) => {
`
}
-const render = async (ele: HTMLElement, content: string) => {
- const code = (content || '').trim()
-
+const init = async (ele: HTMLElement) => {
const div = document.createElement('div')
div.setAttribute('minder-data-type', 'text')
div.style.position = 'relative'
- div.style.height = '400px'
+ div.style.height = '300px'
+ div.style.minHeight = '300px'
ele.innerHTML = ''
ele.appendChild(div)
- const km = new (window as any).kityminder.Minder()
- // Hack 一下，防止脑图自动聚焦
- km.focus = () => 0
+ const km = await newMinder()
+
km.setup(div)
km.disable()
- try {
- await km.importData('text', code)
- km.useTemplate(storage.get(layoutStorageKey, 'default'))
- } catch (error) {
- await km.importData('text', '转换错误\n 1. 请保证大纲只有一个根项目\n 2. 请保证大纲层级正确')
- km.useTemplate('structure')
- }
-
- km.execCommand('hand')
- km.useTheme('fresh-green-compat')
- km.execCommand('camera')
+ km.setOption('defaultTheme', 'fresh-green-compat')
+ km.setTemplate(storage.get(layoutStorageKey, 'default'))
const switchLayout = () => {
const tplList = ['default', 'right', 'structure', 'filetree', 'tianpan', 'fish-bone']
@@ -117,25 +306,32 @@ const render = async (ele: HTMLElement, content: string) => {
const zoomOut = () => km.execCommand('zoomOut')
const zoomIn = () => km.execCommand('zoomIn')
+ const fitHeight = () => {
+ const paper = km.getPaper()
+ const kmView = paper.container
+ const svgG = paper.shapeNode
+ if (kmView && svgG) {
+ kmView.style.height = (svgG.getBoundingClientRect().height + 40) + 'px'
+ km._modules.View.events.resize.apply(km)
+ km.zoom(km.getZoomValue()) // reset view port
+ setTimeout(() => {
+ km.execCommand('camera')
+ }, 0)
+ }
+ }
const exportData = async (type: 'png' | 'svg' | 'km') => {
- const download = (url: string, name: string) => {
- const link = document.createElement('a')
- link.href = dataURItoBlobLink(url)
- link.target = '_blank'
- link.download = name
- link.click()
- }
+ const filename = `mindmap-${Date.now()}.${type}`
switch (type) {
case 'svg':
- download('data:image/svg+xml;base64,' + crypto.strToBase64(await km.exportData('svg')), 'mindmap.svg')
+ downloadDataURL(filename, 'data:image/svg+xml;base64,' + strToBase64(await km.exportData('svg')))
break
case 'km':
- download('data:application/octet-stream;base64,' + crypto.strToBase64(await km.exportData('json')), 'mindmap.km')
+ downloadDataURL(filename, 'data:application/octet-stream;base64,' + strToBase64(await km.exportData('json')))
break
case 'png':
- download(await km.exportData('png'), 'mindmap.png')
+ downloadDataURL(filename, await km.exportData('png'))
break
default:
break
@@ -144,7 +340,7 @@ const render = async (ele: HTMLElement, content: string) => {
const buildButton = (text: string, fun: () => void, onclick = '') => {
const button = document.createElement('button')
- button.style.cssText = 'margin-left: 5px;font-size: 14px;background: #cacaca; border: 0; padding: 0 6px; color: #2c2b2b; cursor: pointer; border-radius: 2px; transition: all .1s ease-in-out; line-height: 24px;'
+ button.className = 'small'
button.innerText = text
button.onclick = fun
button.dataset.onclick = `${onclick}()`
@@ -152,59 +348,161 @@ const render = async (ele: HTMLElement, content: string) => {
}
const action = document.createElement('div')
- action.className = 'no-print'
- action.style.cssText = 'position: absolute; right: 15px; top: 3px; z-index: 1;'
- action.appendChild(buildButton('放大', zoomIn, 'zoomIn'))
- action.appendChild(buildButton('缩小', zoomOut, 'zoomOut'))
- action.appendChild(buildButton('切换布局', switchLayout, 'switchLayout'))
- action.appendChild(buildButton('紧凑/宽松', switchCompat, 'switchCompat'))
+ action.className = 'mind-map-action skip-print'
+ action.appendChild(buildButton(t('mind-map.zoom-in'), zoomIn, 'zoomIn'))
+ action.appendChild(buildButton(t('mind-map.zoom-out'), zoomOut, 'zoomOut'))
+ action.appendChild(buildButton(t('mind-map.switch-layout'), switchLayout, 'switchLayout'))
+ action.appendChild(buildButton(t('mind-map.switch-loose'), switchCompat, 'switchCompat'))
const actionsStr = action.outerHTML.replace(/data-onclick/g, 'onclick')
- action.appendChild(buildButton('新窗口打开', () => {
+ action.appendChild(buildButton(t('open-in-new-window'), () => {
const srcdoc = buildSrcdoc(JSON.stringify(km.exportJson()), actionsStr)
- env.openWindow(buildSrc(srcdoc, '查看图形'), '_blank', { backgroundColor: '#fff' })
+ openWindow(buildSrc(srcdoc, t('view-figure'), true), '_blank', { backgroundColor: '#fff' })
}))
- action.appendChild(buildButton('导出 PNG', () => exportData('png')))
- action.appendChild(buildButton('导出 SVG', () => exportData('svg')))
- action.appendChild(buildButton('导出 KM', () => exportData('km')))
+ action.prepend(buildButton(t('mind-map.fit-height'), fitHeight, 'fitHeight'))
+ action.appendChild(buildButton('PNG', () => exportData('png')))
+ action.appendChild(buildButton('SVG', () => exportData('svg')))
+ action.appendChild(buildButton('KM', () => exportData('km')))
div.appendChild(action)
+
+ return km
+}
+
+const render = async (km: any, content: string) => {
+ if (!km) return
+
+ let code = (content || '').trim()
+
+ try {
+ // replace 2 spaces to 4 spaces
+ if (code.match(/^ {2}[^ ]/gm)) {
+ code = code.replace(/^ {2,}[^ ]/gm, (match) => {
+ return match.replace(/ {2}/g, ' ')
+ })
+ }
+
+ await km.importData('text', code)
+ } catch (error) {
+ await km.importData('text', t('mind-map.convert-error'))
+ km?.execCommand('camera')
+ }
}
const MindMap = defineComponent({
name: 'mind-map',
props: {
+ attrs: Object,
content: {
type: String,
default: ''
}
},
setup (props) {
+ const id = `mind-map-${mindMapId++}`
const container = ref()
+ const img = ref('')
- const renderMindMap = debounce(() => {
- container.value && render(container.value, props.content)
- }, 1000, { leading: true })
+ let km: any = null
+ const renderMindMap = debounce(async () => {
+ if (!container.value) {
+ return
+ }
+
+ if (!km) {
+ km = await init(container.value)
+ km.disableAnimationAwhile(async () => {
+ await render(km, props.content)
+ km?.execCommand('hand')
+ km?.execCommand('camera')
+ })
+ instances.set(id, km)
+ } else {
+ km.disableAnimationAwhile(() => render(km, props.content))
+ }
+ }, 200, { leading: true })
+
+ function clean () {
+ km && km.destroy()
+ km = null
+ instances.delete(id)
+ }
+
+ function reload () {
+ clean()
+ renderMindMap()
+ }
+
+ async function beforePrint ({ type }: { type: ExportType }) {
+ if (type === 'print' || type === 'pdf') {
+ const svg = await km.exportData('svg')
+ img.value = 'data:image/svg+xml;base64,' + strToBase64(svg)
+ }
+ }
+
+ function afterPrint () {
+ img.value = ''
+ }
watch(() => props.content, renderMindMap)
- onMounted(renderMindMap)
+ watch(() => store.state.showView, (visible) => {
+ if (visible) {
+ nextTick(reload)
+ }
+ })
+
+ onMounted(() => setTimeout(renderMindMap, 0))
+
+ registerHook('I18N_CHANGE_LANGUAGE', reload)
+ registerHook('EXPORT_BEFORE_PREPARE', beforePrint)
+ registerHook('EXPORT_AFTER_PREPARE', afterPrint)
+ onBeforeUnmount(() => {
+ clean()
+ removeHook('I18N_CHANGE_LANGUAGE', reload)
+ removeHook('EXPORT_BEFORE_PREPARE', beforePrint)
+ removeHook('EXPORT_AFTER_PREPARE', afterPrint)
+ })
- return () => h('div', { ref: container, class: 'mind-map reduce-brightness' })
+ let focused = false
+
+ const className = [
+ 'mind-map',
+ DOM_CLASS_NAME.REDUCE_BRIGHTNESS,
+ DOM_CLASS_NAME.SKIP_EXPORT,
+ DOM_CLASS_NAME.SKIP_PRINT,
+ ].join(' ')
+
+ return () => [
+ img.value ? h('p', { ...props.attrs }, h('img', {
+ src: img.value,
+ [DOM_ATTR_NAME.ONLY_CHILD]: true,
+ })) : null,
+ h('div', {
+ id,
+ ref: container,
+ class: className,
+ [DOM_ATTR_NAME.DISPLAY_NONE]: img.value ? true : undefined,
+ tabIndex: -1,
+ onClickCapture: () => { container.value?.focus() },
+ onFocus: () => { focused = true },
+ onBlur: () => { focused = false },
+ onMousewheelCapture: (e: WheelEvent) => { !focused && e.stopPropagation() },
+ ...props.attrs,
+ })
+ ]
}
})
-const renderRule: Renderer.RenderRule = (tokens, idx, options, { source }, slf) => {
+const renderRule: Renderer.RenderRule = (tokens, idx, options, { bMarks, source }, slf) => {
const token = tokens[idx]
const nextToken = tokens[idx + 1]
- if (token.level === 0 && token.map && nextToken && nextToken.attrGet('class')?.includes('mindmap')) {
+ if (token.map && nextToken && nextToken.attrGet('class')?.includes('mindmap')) {
const content = source
- .split('\n')
- .slice(token.map[0], token.map[1])
- .join('\n')
+ .substring(bMarks[token.map[0]], bMarks[token.map[1]])
.replace(/\{.mindmap[^}]*\}/gm, '')
.replace(/^(\s*)([+-]*|\d+.) /gm, '$1')
- return h(MindMap, { content }) as any
+ return h(MindMap, { attrs: token.meta?.attrs, content }) as any
}
return slf.renderToken(tokens, idx, options)
@@ -213,25 +511,76 @@ const renderRule: Renderer.RenderRule = (tokens, idx, options, { source }, slf)
export default {
name: 'markdown-mind-map',
register: ctx => {
- ctx.markdown.registerPlugin(md => {
- md.renderer.rules.bullet_list_open = renderRule
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .mind-map {
+ overflow: hidden;
+ }
+
+ .markdown-view .markdown-body .mind-map > div {
+ margin-top: -20px;
+ }
- const style = document.createElement('link')
- style.rel = 'stylesheet'
- style.href = '/kity/kityminder.core.css'
- document.getElementsByTagName('head')[0].appendChild(style)
+ .markdown-view .markdown-body .mind-map .mind-map-action {
+ position: absolute;
+ right: 10px;
+ top: 23px;
+ z-index: 1;
+ text-align: right;
+ background: transparent;
+ opacity: 0;
+ transition: opacity .2s;
+ }
+
+ .markdown-view .markdown-body .mind-map:hover .mind-map-action {
+ opacity: 1;
+ }
+ `)
+
+ async function injectScripts () {
+ const style = await ctx.view.addStyleLink('/kity/kityminder.core.css')
+ const script1 = await ctx.view.addScript('/kity/kity.min.js')
+ script1.onload = async () => {
+ const script2 = await ctx.view.addScript('/kity/kityminder.core.min.js')
+ links = [style.outerHTML, script1.outerHTML, script2.outerHTML].join('\n')
+ }
+ }
- const script1 = document.createElement('script')
- script1.src = '/kity/kity.min.js'
- script1.async = false
- document.body.appendChild(script1)
+ injectScripts()
+
+ ctx.markdown.registerPlugin(async md => {
+ md.renderer.rules.bullet_list_open = renderRule
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', async ({ node, options }) => {
+ if (node.classList.contains('mind-map') && node.id) {
+ const km = instances.get(node.id)
+ if (km) {
+ const img = document.createElement('img')
+ img.alt = 'mind-map'
+ img.setAttribute(DOM_ATTR_NAME.ONLY_CHILD, 'true')
+
+ if (options.preferPng) {
+ img.src = await km.exportData('png')
+ } else {
+ const svg = await km.exportData('svg')
+ img.src = 'data:image/svg+xml;base64,' + ctx.utils.strToBase64(svg)
+ }
+
+ const p = document.createElement('p')
+ Object.assign(p.dataset, node.dataset)
+ p.appendChild(img)
+
+ node.outerHTML = p.outerHTML
+ }
+ }
+ })
- const script2 = document.createElement('script')
- script2.src = '/kity/kityminder.core.min.js'
- script2.async = false
- document.body.appendChild(script2)
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- links = [style.outerHTML, script1.outerHTML, script2.outerHTML].join('\n')
+ items.push(
+ { language: 'markdown', label: '/ + MindMap', insertText: '+ ${1:Subject}{.mindmap}\n + ${2:Topic}', block: true },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-plantuml.ts b/src/renderer/plugins/markdown-plantuml.ts
index 532425265..9aa08a4bd 100644
--- a/src/renderer/plugins/markdown-plantuml.ts
+++ b/src/renderer/plugins/markdown-plantuml.ts
@@ -1,15 +1,28 @@
// https://github.com/DeepElement/markdown-it-plantuml-offline
import { debounce } from 'lodash-es'
+import pako from 'pako'
import { defineComponent, h, nextTick, onMounted, reactive, ref, watch } from 'vue'
import Markdown from 'markdown-it'
import Token from 'markdown-it/lib/token'
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
+import { DOM_ATTR_NAME } from '@fe/support/args'
const emptySrc = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
+const backgroundImage = 'url(data:image/gif;base64,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)'
+
+const baseUrl = location.origin + '/api/plantuml'
const MarkdownItPlugin = function umlPlugin (md: Markdown, options: any) {
function generateSourceDefault (umlCode: string) {
- return location.origin + '/api/plantuml/png?data=' + encodeURIComponent(umlCode)
+ if (!umlCode.trim()) {
+ return 'data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 32 32"><defs><linearGradient id="a" x1="-33.423" y1="-250.911" x2="-33.353" y2="-250.858" gradientTransform="matrix(37.134, 26.001, 13.575, -19.387, 4673.473, -3982.019)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#767676"/><stop offset="1"/></linearGradient><linearGradient id="b" x1="-32.107" y1="-242.563" x2="-32.028" y2="-242.586" gradientTransform="matrix(81.081, 56.774, 17.306, -24.715, 6804.021, -4149.644)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#0079b9"/><stop offset="1"/></linearGradient><linearGradient id="c" x1="-33.282" y1="-243.423" x2="-33.224" y2="-243.455" gradientTransform="matrix(60.003, 42.015, 34.184, -48.82, 10343.005, -10469.084)" xlink:href="#b"/><linearGradient id="d" x1="12.356" y1="26.268" x2="14.011" y2="26.268" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#595959"/><stop offset="0.087" stop-color="#6e6e6e"/><stop offset="0.242" stop-color="#8c8c8c"/><stop offset="0.405" stop-color="#a4a4a4"/><stop offset="0.577" stop-color="#b5b5b5"/><stop offset="0.765" stop-color="#bfbfbf"/><stop offset="1" stop-color="#c2c2c2"/></linearGradient><linearGradient id="e" x1="18.291" y1="26.171" x2="19.946" y2="26.171" xlink:href="#d"/><linearGradient id="f" x1="24.44" y1="26.171" x2="26.096" y2="26.171" xlink:href="#d"/></defs><rect width="100%" height="100%" fill="#fff"/><title>file_type_plantuml</title><polygon points="20.305 17.872 27.16 22.418 21.72 25.493 14.861 20.999 20.305 17.872" style="fill:#1c0a42"/><path d="M21.716,25.619l-.055-.036-7.005-4.59,5.653-3.247,7.056,4.68Zm-6.65-4.613,6.658,4.362,5.231-2.957L20.3,18Z"/><polygon points="26.401 11.909 29.418 13.592 27.07 15.088 24.213 13.247 26.401 11.909" style="fill:url(#a)"/><path d="M27.069,15.215l-3.058-1.97,2.387-1.46,3.228,1.8Zm-2.654-1.966L27.07,14.96,29.208,13.6l-2.8-1.565Z"/><polygon points="14.498 17.807 21.354 22.354 15.914 25.429 9.055 20.935 14.498 17.807" style="fill:#ffbd3f"/><path d="M15.91,25.554l-.055-.036L8.85,20.929,14.5,17.681l7.056,4.68ZM9.26,20.941,15.918,25.3l5.231-2.957-6.654-4.413Z"/><polygon points="7.99 17.966 14.954 22.366 9.577 25.504 2.218 20.849 7.99 17.966" style="fill:#a11f40"/><path d="M9.575,25.629,2,20.838l6-3,7.164,4.527ZM2.436,20.86,9.58,25.378l5.168-3.016L7.984,18.089Z"/><polygon points="2.111 21.021 9.443 25.515 9.443 29.063 2.111 24.332 2.111 21.021" style="fill:url(#b)"/><path d="M9.55,29.26,2,24.391V20.829L9.55,25.455ZM2.218,24.274l7.118,4.592V25.575L2.218,21.213Z"/><polygon points="24.071 13.343 27.009 15.222 27.009 22.131 24.071 20.247 24.071 13.343" style="fill:url(#c)"/><path d="M27.063,22.229l-3.045-1.953V13.245l3.045,1.947Zm-2.938-2.012,2.831,1.815V15.251l-2.831-1.81Z"/><polygon points="27.149 22.526 27.149 15.194 29.514 13.775 29.514 29.149 28.331 29.149 9.646 29.149 9.646 25.601 15.086 22.526 15.785 25.601 15.796 25.601 21.472 22.526 21.891 25.601 21.945 25.601 27.149 22.526" style="fill:#fff"/><path d="M29.621,29.256H9.539V25.538l5.62-3.177.7,3.083,5.7-3.087.422,3.1,5.061-2.991V15.133l2.58-1.548ZM9.753,29.041H29.407V13.964l-2.151,1.29v7.332l-.053.031-5.229,3.09H21.8l-.411-3.014-5.564,3.014H15.7l-.686-3.018-5.26,2.973Z"/><rect x="12.356" y="25.44" width="1.656" height="1.656" rx="0.215" ry="0.215" style="fill:url(#d)"/><path d="M13.8,27.2H12.57a.322.322,0,0,1-.322-.322V25.655a.322.322,0,0,1,.322-.322H13.8a.322.322,0,0,1,.322.322v1.226A.322.322,0,0,1,13.8,27.2ZM12.57,25.547a.108.108,0,0,0-.107.107v1.226a.108.108,0,0,0,.107.107H13.8a.108.108,0,0,0,.107-.107V25.655a.108.108,0,0,0-.107-.107Z"/><rect x="18.291" y="25.343" width="1.656" height="1.656" rx="0.215" ry="0.215" style="fill:url(#e)"/><path d="M19.732,27.106H18.505a.322.322,0,0,1-.322-.322V25.558a.322.322,0,0,1,.322-.322h1.226a.322.322,0,0,1,.322.322v1.226A.322.322,0,0,1,19.732,27.106Zm-1.226-1.656a.108.108,0,0,0-.107.107v1.226a.108.108,0,0,0,.107.107h1.226a.108.108,0,0,0,.107-.107V25.558a.108.108,0,0,0-.107-.107Z"/><rect x="24.44" y="25.343" width="1.656" height="1.656" rx="0.215" ry="0.215" style="fill:url(#f)"/><path d="M25.881,27.106H24.655a.322.322,0,0,1-.322-.322V25.558a.322.322,0,0,1,.322-.322h1.226a.322.322,0,0,1,.322.322v1.226A.322.322,0,0,1,25.881,27.106Zm-1.226-1.656a.108.108,0,0,0-.107.107v1.226a.108.108,0,0,0,.107.107h1.226a.108.108,0,0,0,.107-.107V25.558a.108.108,0,0,0-.107-.107Z"/><path d="M27.215,11.23c-.052.069-.417-.262-.653-.526a4.408,4.408,0,0,1-.516-.73A2.6,2.6,0,0,1,25.7,9.2a2.358,2.358,0,0,1-.052-.682,2.959,2.959,0,0,1,.129-.749,3.142,3.142,0,0,1,.787-1.207,15.532,15.532,0,0,0,1.283-1.4,3.062,3.062,0,0,0,.479-.927,3.979,3.979,0,0,0,.151-.855c.019-.364-.025-.593.023-.613s.215.274.287.564a3.167,3.167,0,0,1-.458,2.1,6.9,6.9,0,0,1-1.094,1.448,2.8,2.8,0,0,0-.849,1.234A2.466,2.466,0,0,0,26.3,8.8a3.465,3.465,0,0,0,.476,1.542C27.064,10.914,27.256,11.175,27.215,11.23Z" style="fill:#ea2d2e"/><path d="M27.193,11.266c-.124,0-.492-.365-.651-.544a4.478,4.478,0,0,1-.52-.734,2.628,2.628,0,0,1-.346-.781,2.375,2.375,0,0,1-.053-.69,2.978,2.978,0,0,1,.13-.756,3.208,3.208,0,0,1,.793-1.216c.294-.331.5-.528.659-.686a4.393,4.393,0,0,0,.622-.711,3.052,3.052,0,0,0,.476-.919,3.951,3.951,0,0,0,.15-.849c.008-.159,0-.294,0-.393,0-.159-.006-.225.038-.243a.05.05,0,0,1,.043,0,1.226,1.226,0,0,1,.28.579,3.167,3.167,0,0,1-.46,2.121,6.928,6.928,0,0,1-1.1,1.453c-.055.06-.109.116-.162.171a2.3,2.3,0,0,0-.681,1.052,2.47,2.47,0,0,0-.082.673,3.458,3.458,0,0,0,.473,1.53c.114.231.215.415.289.549.129.235.178.323.142.369h0a.051.051,0,0,1-.04.02ZM28.512,2.8a.863.863,0,0,0,0,.19c0,.1.007.236,0,.4a4.021,4.021,0,0,1-.152.861,3.106,3.106,0,0,1-.483.934,4.437,4.437,0,0,1-.629.719c-.162.158-.364.354-.657.683a3.168,3.168,0,0,0-.782,1.2,2.933,2.933,0,0,0-.128.743,2.325,2.325,0,0,0,.052.675,2.59,2.59,0,0,0,.341.767,4.422,4.422,0,0,0,.513.725,2.035,2.035,0,0,0,.611.526,1.183,1.183,0,0,0-.147-.31c-.074-.134-.175-.318-.29-.551A3.5,3.5,0,0,1,26.278,8.8a2.53,2.53,0,0,1,.084-.688,2.375,2.375,0,0,1,.694-1.075c.052-.055.106-.111.161-.171a6.879,6.879,0,0,0,1.09-1.442,3.119,3.119,0,0,0,.456-2.083A1.281,1.281,0,0,0,28.512,2.8Z"/><path d="M29.972,6.087c-.019-.088-.432-.04-.766.073a2.6,2.6,0,0,0-1.059.722,2.8,2.8,0,0,0-.916,1.855,2.972,2.972,0,0,0,.258,1.06c.221.572.455.773.444,1.225-.007.3-.114.484-.048.549s.314-.1.462-.313a1.8,1.8,0,0,0,.259-1.022c-.046-.815-.6-1.015-.608-1.8a1.858,1.858,0,0,1,.129-.676C28.57,6.509,30.008,6.252,29.972,6.087Z" style="fill:#ea2d2e"/><path d="M27.934,11.617a.094.094,0,0,1-.069-.026c-.046-.046-.03-.122-.005-.237a1.718,1.718,0,0,0,.045-.331,1.374,1.374,0,0,0-.214-.72,5,5,0,0,1-.228-.495,2.98,2.98,0,0,1-.259-1.07,2.81,2.81,0,0,1,.923-1.874,2.64,2.64,0,0,1,1.07-.729,1.482,1.482,0,0,1,.766-.1A.065.065,0,0,1,30,6.081h0c.015.07-.092.121-.306.224a2.73,2.73,0,0,0-1.542,1.463,1.827,1.827,0,0,0-.127.667,1.645,1.645,0,0,0,.291.885,1.889,1.889,0,0,1,.317.914,1.814,1.814,0,0,1-.264,1.039.809.809,0,0,1-.421.342Zm1.889-5.549a2.117,2.117,0,0,0-.608.117,2.588,2.588,0,0,0-1.048.715,2.764,2.764,0,0,0-.909,1.837,2.935,2.935,0,0,0,.256,1.05,4.955,4.955,0,0,0,.225.49,1.433,1.433,0,0,1,.22.745,1.765,1.765,0,0,1-.047.341c-.019.091-.035.163-.009.188a.046.046,0,0,0,.038.01.769.769,0,0,0,.382-.32,1.793,1.793,0,0,0,.254-1.005,1.844,1.844,0,0,0-.31-.89,1.711,1.711,0,0,1-.3-.911,1.877,1.877,0,0,1,.13-.686A2.776,2.776,0,0,1,29.67,6.257c.126-.061.283-.136.277-.164l-.008-.007A.264.264,0,0,0,29.823,6.068Z"/></svg>
'
+ }
+
+ const data = btoa(
+ pako.deflateRaw(umlCode).reduce((d, b) => d + String.fromCharCode(b), '')
+ )
+
+ return baseUrl + '?data=' + encodeURIComponent(data)
}
options = options || {}
@@ -102,7 +115,7 @@ const MarkdownItPlugin = function umlPlugin (md: Markdown, options: any) {
const contents = state.src
.split('\n')
- .slice(startLine + 1, nextLine)
+ .slice(startLine, nextLine + 1)
.join('\n')
// We generate a token list for the alt property, to mimic what the image parser does.
@@ -139,17 +152,30 @@ const MarkdownItPlugin = function umlPlugin (md: Markdown, options: any) {
alt: ['paragraph', 'reference', 'blockquote', 'list']
})
md.renderer.rules.uml_diagram = render
+
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ const token = tokens[idx]
+ if (token.info !== 'plantuml') {
+ return temp(tokens, idx, options, env, slf)
+ }
+
+ const src = generateSourceDefault(token.content)
+ return h(Plantuml, { attrs: token.meta?.attrs, src, idx }) as any
+ }
}
const Plantuml = defineComponent({
name: 'plantuml-image',
props: {
- src: String
+ attrs: Object,
+ src: String,
+ idx: Number,
},
setup (props) {
const style = reactive({
backgroundColor: 'transparent',
- backgroundImage: 'url(data:image/gif;base64,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)',
+ backgroundImage,
backgroundPosition: 'center',
backgroundRepeat: 'no-repeat',
width: '32px',
@@ -162,15 +188,19 @@ const Plantuml = defineComponent({
const onLoad = () => {
style.width = 'auto'
style.height = 'auto'
+ style.backgroundImage = 'none'
}
const load = debounce((val: string) => {
- src.value = val
+ src.value = emptySrc
+ setTimeout(() => {
+ style.backgroundImage = backgroundImage
+ src.value = val
+ }, 0)
}, 1000)
watch(() => props.src, val => {
- src.value = emptySrc
- nextTick(() => load(val || ''))
+ load(val || '')
})
onMounted(() => {
@@ -186,26 +216,105 @@ const Plantuml = defineComponent({
style.height = img.value.clientHeight + 'px'
}
- return h('img', {
- ref: img,
- alt: 'plantuml',
- class: 'plantuml-img',
- style,
- src: src.value,
- onLoad
- })
+ return h('p', {
+ ...props.attrs,
+ src: undefined,
+ alt: undefined,
+ [DOM_ATTR_NAME.TOKEN_IDX]: props.idx,
+ }, [
+ h('img', {
+ ref: img,
+ alt: 'plantuml',
+ class: 'plantuml-img',
+ [DOM_ATTR_NAME.ONLY_CHILD]: true,
+ style,
+ src: src.value,
+ onload: onLoad
+ })
+ ])
}
}
})
function render (tokens: Token[], idx: number) {
const token = tokens[idx]
- return h(Plantuml, { src: token.attrGet('src') || emptySrc })
+ return h(Plantuml, {
+ attrs: token.meta?.attrs,
+ src: token.attrGet('src') || emptySrc,
+ idx,
+ })
}
export default {
name: 'markdown-plantuml',
register: ctx => {
- ctx.markdown.registerPlugin(MarkdownItPlugin, { render })
+ const markers = [{
+ openMarker: '@startuml',
+ closeMarker: '@enduml',
+ }, {
+ openMarker: '@startsalt',
+ closeMarker: '@endsalt',
+ }, {
+ openMarker: '@startmindmap',
+ closeMarker: '@endmindmap',
+ }, {
+ openMarker: '@startgantt',
+ closeMarker: '@endgantt',
+ }, {
+ openMarker: '@startwbs',
+ closeMarker: '@endwbs',
+ }, {
+ openMarker: '@startjson',
+ closeMarker: '@endjson',
+ }, {
+ openMarker: '@startyaml',
+ closeMarker: '@endyaml',
+ }]
+ markers.forEach((marker) => {
+ ctx.markdown.registerPlugin(MarkdownItPlugin, { render, ...marker })
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', async ({ node, options }) => {
+ const srcAttr = node.getAttribute('src')
+ if (srcAttr?.startsWith(baseUrl)) {
+ node.removeAttribute('style')
+
+ if (options.preferPng || options.inlineLocalImage) {
+ try {
+ const res: Response = await ctx.api.fetchHttp(srcAttr)
+ const base64Url = await ctx.utils.fileToBase64URL(await res.blob())
+ node.setAttribute('src', base64Url)
+ } catch (error) {
+ console.log(error)
+ }
+ }
+ }
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` PlantUML', insertText: '```plantuml\n@startuml\n${1:a -> b}\n@enduml\n```\n', block: true },
+ { language: 'markdown', label: '/ @startuml PlantUML', insertText: '@startuml\n${1:a -> b}\n@enduml\n', block: true },
+ { language: 'markdown', label: '/ @startsalt PlantUML Salt', insertText: '@startsalt\n{\n Just plain text\n [This is my button]\n () Unchecked radio\n (X) Checked radio\n [] Unchecked box\n [X] Checked box\n "Enter text here "\n ^This is a droplist^\n}\n@endsalt\n', block: true },
+ { language: 'markdown', label: '/ @startmindmap PlantUML Mindmap', insertText: '@startmindmap\n* Debian\n** Ubuntu\n*** Linux Mint\n*** Kubuntu\n*** Lubuntu\n*** KDE Neon\n** LMDE\n** SolydXK\n** SteamOS\n** Raspbian with a very long name\n*** Raspmbc => OSMC\n*** Raspyfi => Volumio\n@endmindmap\n', block: true },
+ { language: 'markdown', label: '/ @startgantt PlantUML Gantt', insertText: '@startgantt\nProject starts 2020-07-01\n[Test prototype] lasts 10 days\n[Prototype completed] happens 2020-07-10\n[Setup assembly line] lasts 12 days\n[Setup assembly line] starts at [Test prototype]\'s end\n@endgantt\n', block: true },
+ { language: 'markdown', label: '/ @startwbs PlantUML Wbs', insertText: '@startwbs\n* Business Process Modelling WBS\n** Launch the project\n*** Complete Stakeholder Research\n*** Initial Implementation Plan\n** Design phase\n*** Model of AsIs Processes Completed\n****< Model of AsIs Processes Completed1\n****> Model of AsIs Processes Completed2\n***< Measure AsIs performance metrics\n***< Identify Quick Wins\n@endwbs\n', block: true },
+ { language: 'markdown', label: '/ @startjson PlantUML Json', insertText: '@startjson\n{\n "fruit":"Apple",\n "size":"Large",\n "color": ["Red", "Green"]\n}\n@endjson\n', block: true },
+ { language: 'markdown', label: '/ @startyaml PlantUML Yaml', insertText: '@startyaml\nfruit: Apple\nsize: Large\ncolor: \n - Red\n - Green\n@endyaml\n', block: true },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/^@@start(uml|salt|mindmap|gantt|wbs|json|yaml)$/, { token: 'string', next: '@plantuml' }],
+ )
+
+ mdLanguage.tokenizer.plantuml = [
+ [/^@@end(uml|salt|mindmap|gantt|wbs|json|yaml)$/, { token: 'string', next: '@pop' }],
+ [/.*$/, 'variable.source']
+ ]
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-render-vnode.ts b/src/renderer/plugins/markdown-render-vnode.ts
index 55917608d..30d20191e 100644
--- a/src/renderer/plugins/markdown-render-vnode.ts
+++ b/src/renderer/plugins/markdown-render-vnode.ts
@@ -1,12 +1,85 @@
-import { createVNode, Fragment, Text, VNode } from 'vue'
-import Token from 'markdown-it/lib/token'
-import Renderer from 'markdown-it/lib/renderer'
+import { createVNode, Fragment, Comment, Text, VNode } from 'vue'
+import type Token from 'markdown-it/lib/token'
+import type Renderer from 'markdown-it/lib/renderer'
import { escapeHtml, unescapeAll } from 'markdown-it/lib/common/utils'
-import { Plugin } from '@fe/context/plugin'
+import { DOM_ATTR_NAME } from '@fe/support/args'
+import type { Plugin } from '@fe/context'
-const attrNameReg = /^[a-zA-Z_:][a-zA-Z0-9:._-]*/
+const sensitiveUrlReg = /^javascript:|vbscript:|file:/i
+const sensitiveAttrReg = /^href|src|xlink:href|poster|srcset$/i
+const attrNameReg = /^[a-zA-Z_:][a-zA-Z0-9:._-]*$/
+const attrEventReg = /^on/i
const defaultRules = {} as any
+function onLeavepictureinpicture (e: Event) {
+ const target = e.target as HTMLMediaElement
+ if (!target.isConnected) {
+ target.pause()
+ } else {
+ (target as any).scrollIntoViewIfNeeded()
+ }
+}
+
+function validateAttrName (name: string) {
+ return attrNameReg.test(name) && !attrEventReg.test(name)
+}
+
+function getLine (token: Token, env?: Record) {
+ const [lineStart, lineEnd] = token.map || [0, 1]
+
+ // macro, calc line offset, see `markdown-macro` plugin.
+ let sOffset = 0
+ if (env?.macroLines && env.bMarks && env.eMarks) {
+ const sPos = env.bMarks[lineStart]
+ for (let i = 0; i < env.macroLines.length; i++) {
+ const { matchPos, lineOffset, posOffset, currentPosOffset } = env.macroLines[i]
+ if (sPos + posOffset > matchPos && sPos + posOffset - currentPosOffset > matchPos) {
+ sOffset = lineOffset
+ } else {
+ break
+ }
+ }
+ }
+
+ return [lineStart + sOffset, lineEnd + sOffset]
+}
+
+function processToken (token: Token, env?: Record) {
+ if (!token.meta) {
+ token.meta = {}
+ }
+
+ if (env?.safeMode) {
+ token.attrs?.forEach(([name, val]) => {
+ name = name.toLowerCase()
+ if (sensitiveAttrReg.test(name) && sensitiveUrlReg.test(val)) {
+ token.attrSet(name, '')
+ }
+
+ if (name === 'href' && val.toLowerCase().startsWith('data:')) {
+ token.attrSet(name, '')
+ }
+ })
+ }
+
+ if (token.block) {
+ const [lineStart, lineEnd] = getLine(token, env)
+
+ if (token.map) {
+ token.attrSet(DOM_ATTR_NAME.SOURCE_LINE_START, String(lineStart + 1))
+ token.attrSet(DOM_ATTR_NAME.SOURCE_LINE_END, String(lineEnd + 1))
+ if (!token.meta.attrs) {
+ token.meta.attrs = {}
+ }
+
+ // transform array to object
+ token.attrs?.forEach(([name, val]) => {
+ token.meta.attrs[name] = val
+ })
+ }
+ }
+}
+
defaultRules.code_inline = function (tokens: Token[], idx: number, _: any, __: any, slf: Renderer) {
const token = tokens[idx]
return createVNode('code', slf.renderAttrs(token) as any, token.content)
@@ -14,10 +87,19 @@ defaultRules.code_inline = function (tokens: Token[], idx: number, _: any, __: a
defaultRules.code_block = function (tokens: Token[], idx: number, _: any, __: any, slf: Renderer) {
const token = tokens[idx]
+ const attrs: any = slf.renderAttrs(token)
+ const preAttrs = {
+ [DOM_ATTR_NAME.SOURCE_LINE_START]: attrs[DOM_ATTR_NAME.SOURCE_LINE_START],
+ [DOM_ATTR_NAME.SOURCE_LINE_END]: attrs[DOM_ATTR_NAME.SOURCE_LINE_END],
+ }
+
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_START]
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_END]
+
return createVNode(
'pre',
- slf.renderAttrs(token) as any,
- [createVNode('code', {}, token.content)]
+ preAttrs,
+ [createVNode('code', attrs, [createVNode(Text, {}, token.content)])]
)
}
@@ -44,11 +126,23 @@ defaultRules.fence = function (tokens: Token[], idx: number, options: any, _: an
return highlighted + '\n'
}
- const buildVNode = (arrts: any) => createVNode(
- 'pre',
- {},
- [createVNode('code', { ...arrts, innerHTML: highlighted }, [])]
- )
+ const buildVNode = (attrs: any) => {
+ const preAttrs = {
+ 'data-info': info,
+ 'data-lang': langName,
+ [DOM_ATTR_NAME.SOURCE_LINE_START]: attrs[DOM_ATTR_NAME.SOURCE_LINE_START],
+ [DOM_ATTR_NAME.SOURCE_LINE_END]: attrs[DOM_ATTR_NAME.SOURCE_LINE_END],
+ }
+
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_START]
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_END]
+
+ return createVNode(
+ 'pre',
+ preAttrs,
+ [createVNode('code', { key: highlighted, ...attrs, innerHTML: highlighted }, [])]
+ )
+ }
// If language exists, inject class gently, without modifying original token.
// May be, one day we will add .deepClone() for token and simplify this part, but
@@ -84,6 +178,16 @@ defaultRules.image = function (tokens: Token[], idx: number, options: any, env:
}, [])
}
+defaultRules.media = function (tokens: Token[], idx: number, _options: any, _env: any, slf: Renderer) {
+ const token = tokens[idx]
+ return createVNode(token.tag, {
+ controlsList: 'nodownload',
+ controls: true,
+ onLeavepictureinpicture,
+ ...slf.renderAttrs(token) as any,
+ }, [])
+}
+
defaultRules.hardbreak = function () {
return createVNode('br')
}
@@ -96,19 +200,30 @@ defaultRules.text = function (tokens: Token[], idx: number) {
}
defaultRules.html_block = function (tokens: Token[], idx: number) {
- return createHtmlVNode(tokens[idx].content)
+ const token = tokens[idx] as any
+ if (token.contentVNode) {
+ return token.contentVNode
+ }
+
+ return createHtmlVNode(token.content)
}
defaultRules.html_inline = function (tokens: Token[], idx: number) {
- return createHtmlVNode(tokens[idx].content)
+ const token = tokens[idx] as any
+ if (token.contentVNode) {
+ return token.contentVNode
+ }
+
+ return createHtmlVNode(token.content)
}
function createHtmlVNode (html: string) {
- const div = document.createElement('div')
+ const div = document.createElement('template')
div.innerHTML = html
+ const elements = div.content.children
const children = []
- for (let i = 0; i < div.children.length; i++) {
- const element = div.children[i]
+ for (let i = 0; i < elements.length; i++) {
+ const element = elements[i]
const tagName = element.tagName.toLowerCase()
const attrs: Record = {
key: element.outerHTML
@@ -120,8 +235,9 @@ function createHtmlVNode (html: string) {
}
attrs.innerHTML = element.innerHTML
+ attrs.key = element.innerHTML
- children.push(createVNode(tagName, attrs))
+ children.push(createVNode(tagName, attrs, []))
}
return createVNode(Fragment, {}, children)
@@ -139,6 +255,10 @@ function renderToken (this: Renderer, tokens: Token[], idx: number): any {
return createVNode(Fragment, {}, [])
}
+ if (token.tag === '--') {
+ return createVNode(Comment)
+ }
+
return createVNode(token.tag, this.renderAttrs(token) as any, [])
}
@@ -150,7 +270,7 @@ function renderAttrs (this: Renderer, token: Token) {
const result: any = {}
token.attrs.forEach(token => {
- if (attrNameReg.test(token[0])) {
+ if (validateAttrName(token[0])) {
result[token[0]] = token[1]
}
})
@@ -164,6 +284,11 @@ function render (this: Renderer, tokens: Token[], options: any, env: any) {
const vNodeParents: VNode[] = []
return tokens.map((token, i) => {
+ processToken(token, env)
+ if (token.block) {
+ token.attrSet(DOM_ATTR_NAME.TOKEN_IDX, i.toString())
+ }
+
const type = token.type
let vnode: VNode | null = null
@@ -188,8 +313,10 @@ function render (this: Renderer, tokens: Token[], options: any, env: any) {
let isChild = false
const parentNode = vNodeParents.length > 0 ? vNodeParents[vNodeParents.length - 1] : null
if (vnode && parentNode) {
- const children = Array.isArray(parentNode.children) ? parentNode.children : []
- parentNode.children = children.concat([vnode])
+ if (typeof parentNode.type === 'string' || parentNode.type === Fragment) {
+ const children = Array.isArray(parentNode.children) ? parentNode.children : []
+ parentNode.children = children.concat([vnode])
+ }
isChild = true
}
diff --git a/src/renderer/plugins/markdown-run-code.ts b/src/renderer/plugins/markdown-run-code.ts
deleted file mode 100644
index f7f2d3d33..000000000
--- a/src/renderer/plugins/markdown-run-code.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-import { computed, defineComponent, h, onBeforeUnmount, ref, VNode } from 'vue'
-import CryptoJS from 'crypto-js'
-import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { getAction } from '@fe/context/action'
-import * as api from '@fe/support/api'
-import { FLAG_DISABLE_XTERM } from '@fe/support/global-args'
-import storage from '@fe/utils/storage'
-
-const cachePrefix = 'run_code_result_'
-
-const RunCode = defineComponent({
- name: 'run-code',
- props: {
- code: {
- type: String,
- default: ''
- },
- language: String,
- },
- setup (props) {
- const result = ref('')
- const hash = computed(() => CryptoJS.MD5(props.code).toString())
- const id = Date.now()
- let hasResult = false
-
- let appendLog: any = (res: string) => {
- if (hasResult) {
- result.value += '\n' + res
- } else {
- result.value = res
- hasResult = true
- }
-
- storage.set(`${cachePrefix}${hash.value}`, result.value)
- }
-
- const run = async () => {
- const { code, language } = props
-
- hasResult = false
- result.value = '运行中……'
-
- try {
- await api.runCode(language!, code, {
- name: `_l_${id}_${hash.value}`,
- handler: res => appendLog && appendLog(res)
- })
- } catch (error) {
- result.value = error.message
- }
- }
-
- const runInXterm = (e: MouseEvent) => {
- getAction('xterm.run-code')(props.language, props.code, e.ctrlKey)
- }
-
- onBeforeUnmount(() => {
- appendLog = undefined
- })
-
- return () => {
- const runResult = result.value || storage.get(`${cachePrefix}${hash.value}`, '')
-
- return [
- h('div', { class: 'run-code-action', style: 'position: sticky; left: 0; border-top: dashed 1px #888; margin: 1em 0' }, [
- h('div', {
- title: '运行代码',
- style: 'position: absolute; top: -.7em; height: 0; width: 0; border-left: .7em #b7b3b3 solid; border-top: .6em #dddddd00 solid; border-bottom: .6em #dddddd00 solid; border-right: 0; background: rgba(0, 0, 0, 0); cursor: pointer; outline: none',
- onClick: run
- }),
- h('div', {
- title: '在终端中运行代码，Ctrl + 单击不退出解释器',
- class: 'no-print',
- style: 'position: absolute; top: -.5em; right: -0; height: 0; width: 0; border-left: .7em #b7b3b3 solid; border-top: .6em #dddddd00 solid; border-bottom: .6em #dddddd00 solid; border-right: 0; background: rgba(0, 0, 0, 0); cursor: pointer; outline: none;transform: rotate(90deg);',
- onClick: runInXterm
- }),
- ]),
- h('div', { class: 'run-code-result', style: 'padding: .5em 0', innerHTML: runResult }),
- ]
- }
- }
-})
-
-const RunPlugin = (md: Markdown) => {
- const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
- md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
- const token = tokens[idx]
-
- const code = token.content.trim()
- const firstLine = code.split(/\n/)[0].trim()
- if (!firstLine.includes('--run--')) {
- return temp(tokens, idx, options, env, slf)
- }
-
- const codeNode: VNode = temp(tokens, idx, options, env, slf) as any
-
- if (codeNode && Array.isArray(codeNode.children)) {
- codeNode.children.push(h(RunCode, {
- code,
- language: token.info
- }))
- }
-
- return codeNode as any
- }
-}
-
-const clearCache = () => {
- Object.keys(storage.getAll()).forEach(key => {
- if (key.startsWith(cachePrefix)) {
- storage.remove(key)
- }
- })
-}
-
-export default {
- name: 'run-code',
- register: ctx => {
- ctx.theme.addStyles(`
- @media print {
- .markdown-view .markdown-body .run-code-result {
- white-space: pre-wrap;
- }
- }
- `)
-
- ctx.markdown.registerPlugin(RunPlugin)
- ctx.registerHook('ON_STARTUP', clearCache)
-
- !FLAG_DISABLE_XTERM && ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
- editor.addAction({
- id: 'plugin.editor.run-in-xterm',
- label: '终端中运行',
- contextMenuGroupId: 'other',
- precondition: 'editorHasSelection',
- keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_R
- ],
- run: () => {
- getAction('xterm.run')(editor.getModel()!.getValueInRange(editor.getSelection()!))
- }
- })
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-source-line.ts b/src/renderer/plugins/markdown-source-line.ts
deleted file mode 100644
index 198f23800..000000000
--- a/src/renderer/plugins/markdown-source-line.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { Plugin } from '@fe/context/plugin'
-import Renderer from 'markdown-it/lib/renderer'
-
-const buildFunction = (className: string): Renderer.RenderRule => {
- return (tokens, idx, options, _, slf) => {
- if (tokens[idx].map) {
- const lineStart = tokens[idx].map![0]
- const lineEnd = tokens[idx].map![1]
- tokens[idx].attrJoin('class', className)
- tokens[idx].attrSet('data-source-line', String(lineStart + 1))
- tokens[idx].attrSet('data-source-line-end', String(lineEnd + 1))
- }
- return slf.renderToken(tokens, idx, options)
- }
-}
-
-export const injectLineNumbers = buildFunction('source-line')
-
-export default {
- name: 'markdown-source-line',
- register: ctx => {
- ctx.markdown.registerPlugin(md => {
- md.renderer.rules.paragraph_open = injectLineNumbers
- md.renderer.rules.heading_open = injectLineNumbers
- md.renderer.rules.list_item_open = injectLineNumbers
- md.renderer.rules.table_open = injectLineNumbers
- md.renderer.rules.td_open = buildFunction('yank-table-cell')
- md.renderer.rules.th_open = buildFunction('yank-table-cell')
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-table.ts b/src/renderer/plugins/markdown-table.ts
new file mode 100644
index 000000000..d2d6c904b
--- /dev/null
+++ b/src/renderer/plugins/markdown-table.ts
@@ -0,0 +1,949 @@
+import { nextTick, reactive } from 'vue'
+import Sortable from 'sortablejs'
+import { orderBy } from 'lodash-es'
+import type { Plugin } from '@fe/context'
+import { useModal } from '@fe/support/ui/modal'
+import { hasCtrlCmd } from '@fe/core/keybinding'
+import { DOM_ATTR_NAME, FLAG_READONLY } from '@fe/support/args'
+import { useToast } from '@fe/support/ui/toast'
+import { disableSyncScrollAwhile, renderImmediately } from '@fe/services/view'
+import * as editor from '@fe/services/editor'
+import { t } from '@fe/services/i18n'
+import { getLogger } from '@fe/utils'
+import type Token from 'markdown-it/lib/token'
+import type Renderer from 'markdown-it/lib/renderer'
+import type { Components } from '@fe/types'
+
+const tableSortMode = 'sort-mode'
+const cellClassName = 'yn-table-cell'
+const logger = getLogger('markdown-table')
+
+function editWrapper, U> (fn: (...args: T) => U) {
+ return function (...args: T) {
+ disableSyncScrollAwhile(() => {
+ fn(...args)
+ })
+ }
+}
+
+const getLineContent = editor.getLineContent
+const deleteLine = editWrapper(editor.deleteLine)
+const replaceLine = editWrapper(editor.replaceLine)
+
+function injectClass (tokens: Token[], idx: number, options: any, env: any, slf: Renderer) {
+ const token = tokens[idx]
+ token.attrJoin('class', cellClassName)
+ return slf.renderToken(tokens, idx, options)
+}
+
+function resetInput (input: HTMLTextAreaElement) {
+ input.parentElement!.style.position = ''
+ input.onblur = () => undefined
+ input.remove()
+}
+
+function escapedSplit (str: string) {
+ const result = []
+ const max = str.length
+ let pos = 0
+ let ch = str.charCodeAt(pos)
+ let isEscaped = false
+ let lastPos = 0
+ let current = ''
+
+ while (pos < max) {
+ if (ch === 0x7c/* | */) {
+ if (!isEscaped) {
+ // pipe separating cells, '|'
+ result.push(current + str.substring(lastPos, pos))
+ current = ''
+ lastPos = pos + 1
+ } else {
+ // escaped pipe, '\|'
+ current += str.substring(lastPos, pos - 1)
+ lastPos = pos
+ }
+ }
+
+ isEscaped = (ch === 0x5c/* \ */)
+ pos++
+
+ ch = str.charCodeAt(pos)
+ }
+
+ result.push(current + str.substring(lastPos))
+
+ if (result.length && result[0] === '') result.shift()
+ if (result.length && result[result.length - 1] === '') result.pop()
+
+ return result
+}
+
+function checkLineNumber (start: number, end: number) {
+ if (start >= 0 && end >= 0 && end - start === 1) {
+ return true
+ }
+
+ useToast().show('warning', t('table-cell-edit.limit-single-line'))
+ return false
+}
+
+function columnsToStr (columns: string[], refText: string) {
+ let content = columns.map(value => {
+ if (!value.startsWith(' ')) {
+ value = ' ' + value
+ }
+
+ if (!value.endsWith(' ')) {
+ value += ' '
+ }
+
+ return value.replace(/\|/g, '\\|').replace(/\n/g, ' ')
+ }).join('|').trim()
+
+ refText = refText.trim()
+
+ if (refText.startsWith('|')) content = '| ' + content
+ if (refText.endsWith('|')) content = content + ' |'
+
+ return content
+}
+
+function getCellIndex (td: HTMLTableCellElement) {
+ return [...td.parentElement!.children as any]
+ .slice(0, td.cellIndex)
+ .reduce((prev, current) => prev + current.colSpan, 0)
+}
+
+type Row = { type: 'head' | 'hr' | 'body', start: number, end: number }
+function getRows (td: HTMLTableCellElement): Row[] {
+ let tbody
+ let thead
+ if (td.tagName === 'TD') {
+ tbody = td.parentElement?.parentElement
+ thead = tbody?.previousElementSibling
+ } else if (td.tagName === 'TH') {
+ thead = td.parentElement?.parentElement
+ tbody = thead?.nextElementSibling
+ } else {
+ return []
+ }
+
+ if (!tbody || !thead) {
+ return []
+ }
+
+ const headRows: Row[] = [...thead.children].map(th => {
+ const td = th.children[0] as HTMLElement | undefined
+
+ const start = parseInt(td?.dataset?.sourceLine || '0')
+ const end = parseInt(td?.dataset?.sourceLineEnd || '0')
+
+ return { type: 'head', start, end }
+ })
+
+ if (headRows.length < 1) {
+ return []
+ }
+
+ const bodyRows: Row[] = [...tbody.children].map(tr => {
+ const td = tr.children[0] as HTMLElement | undefined
+
+ const start = parseInt(td?.dataset?.sourceLine || '0')
+ const end = parseInt(td?.dataset?.sourceLineEnd || '0')
+
+ return { type: 'body', start, end }
+ })
+
+ const lastHeadRows = headRows[headRows.length - 1]
+ return headRows.concat([
+ { type: 'hr', start: lastHeadRows.start + 1, end: lastHeadRows.end + 1 }
+ ]).concat(bodyRows)
+}
+
+async function editTableCell (start: number, end: number, cellIndex: number, input: HTMLTextAreaElement | null) {
+ const toast = useToast()
+ const modal = useModal()
+
+ if (!checkLineNumber(start, end)) {
+ input && input.remove()
+ return
+ }
+
+ const text = getLineContent(start)
+
+ const columns = escapedSplit(text)
+ const cellText = columns[cellIndex]?.replace(/^ | $/g, '')
+
+ if (typeof cellText !== 'string') {
+ throw new Error(t('table-cell-edit.edit-error'))
+ }
+
+ let value = cellText
+ let inComposition = false
+ let nextAction: 'edit-next-cell' | 'edit-prev-cell' | 'edit-bellow-cell' | 'edit-above-cell' | undefined
+ let isCancel = false
+
+ if (input) {
+ input.value = cellText
+ input.select()
+ value = await (new Promise((resolve) => {
+ const cancel = () => {
+ resetInput(input)
+ resolve('')
+ isCancel = true
+ }
+
+ const ok = () => {
+ if (input.value !== cellText) {
+ resolve(input.value)
+ resetInput(input)
+ } else {
+ cancel()
+ }
+ }
+
+ input.onblur = ok
+
+ input.onkeydown = e => {
+ if (inComposition) {
+ return
+ }
+
+ if (e.key === 'Escape') {
+ cancel()
+ }
+
+ if (e.key === 'Tab') {
+ nextAction = e.shiftKey ? 'edit-prev-cell' : 'edit-next-cell'
+ ok()
+
+ e.preventDefault()
+ e.stopPropagation()
+ }
+
+ if (e.key === 'Enter') {
+ if (hasCtrlCmd(e) && !e.shiftKey && !e.altKey) {
+ // insert br
+ const startPos = input.selectionStart
+ const endPos = input.selectionEnd
+ input.value = input.value.substring(0, startPos) + '\n' + input.value.substring(endPos)
+ } else if (hasCtrlCmd(e) && e.shiftKey) {
+ const td = input.parentElement as HTMLTableCellElement
+ ok()
+ addRow(td, 1)
+ nextAction = 'edit-bellow-cell'
+ } else if (e.shiftKey) {
+ ok()
+ nextAction = 'edit-above-cell'
+ } else {
+ ok()
+ nextAction = 'edit-bellow-cell'
+ }
+
+ e.preventDefault()
+ e.stopPropagation()
+ }
+ }
+
+ input.addEventListener('compositionstart', () => {
+ inComposition = true
+ })
+
+ input.addEventListener('compositionend', () => {
+ inComposition = false
+ })
+ }))
+ } else {
+ const inputVal = await modal.input({
+ title: t('table-cell-edit.edit-title'),
+ type: 'textarea',
+ value: cellText,
+ modalWidth: '600px',
+ hint: t('table-cell-edit.edit-hint'),
+ })
+
+ if (typeof inputVal !== 'string') {
+ toast.show('warning', t('table-cell-edit.canceled'))
+ isCancel = true
+ }
+
+ value = inputVal || ''
+ }
+
+ if (!isCancel) {
+ if (!value.startsWith(' ') && cellIndex > 0) value = ' ' + value
+ if (!value.endsWith(' ') && cellIndex < columns.length - 1) value += ' '
+
+ columns[cellIndex] = value
+
+ replaceLine(start, columnsToStr(columns, text))
+ }
+
+ return nextAction
+}
+
+async function handleClick (e: MouseEvent, modal: boolean) {
+ if (FLAG_READONLY) {
+ return
+ }
+
+ const target = e.target as HTMLElement
+
+ const preventEvent = () => {
+ e.preventDefault()
+ e.stopPropagation()
+ return true
+ }
+
+ if (['TD', 'TH'].includes(target.tagName) && target.classList.contains(cellClassName)) {
+ if ((hasCtrlCmd(e) && !modal) || (!hasCtrlCmd(e) && e.type !== 'contextmenu' && modal)) {
+ return false
+ }
+
+ const handleEditTableCell = (td: HTMLTableCellElement) => {
+ const start = parseInt(td.dataset.sourceLine || '0')
+ const end = parseInt(td.dataset.sourceLineEnd || '0')
+ const cellIndex = getCellIndex(td)
+ const input = modal ? null : document.createElement('textarea')
+
+ if (input) {
+ td.style.position = 'relative'
+ input.style.left = '0'
+ input.style.top = '0'
+ input.style.height = '100%'
+ input.style.width = '100%'
+ input.style.boxSizing = 'border-box'
+ input.style.color = 'var(--g-color-0)'
+ input.style.border = '1px #93e632 solid'
+ input.style.backgroundColor = 'var(--g-color-96)'
+ input.style.fontSize = '13px'
+ input.style.position = 'absolute'
+ input.style.display = 'block'
+ input.style.padding = '3px'
+ input.style.lineHeight = '1.2'
+ ;(input as any).autofocus = true
+ input.placeholder = t('table-cell-edit.esc-to-cancel')
+ setTimeout(() => {
+ input.focus()
+ }, 0)
+
+ td.appendChild(input)
+ }
+
+ editTableCell(start, end, cellIndex, input).catch((e: Error) => {
+ useToast().show('warning', e.message)
+ input && resetInput(input)
+ }).then(nextAction => {
+ if (nextAction) {
+ setTimeout(() => {
+ if (nextAction === 'edit-next-cell' && td.nextElementSibling) {
+ handleEditTableCell(td.nextElementSibling as HTMLTableCellElement)
+ } else if (nextAction === 'edit-prev-cell' && td.previousElementSibling) {
+ handleEditTableCell(td.previousElementSibling as HTMLTableCellElement)
+ } else if (nextAction === 'edit-bellow-cell') {
+ const tr = td.parentElement?.nextElementSibling
+ if (tr && tr.tagName === 'TR') {
+ const nextTd = tr.children[cellIndex] as HTMLTableCellElement
+ if (nextTd && (nextTd.tagName === 'TD' || nextTd.tagName === 'TH')) {
+ handleEditTableCell(nextTd)
+ }
+ }
+ } else if (nextAction === 'edit-above-cell') {
+ const tr = td.parentElement?.previousElementSibling
+ if (tr && tr.tagName === 'TR') {
+ const nextTd = tr.children[cellIndex] as HTMLTableCellElement
+ if (nextTd && (nextTd.tagName === 'TD' || nextTd.tagName === 'TH')) {
+ handleEditTableCell(nextTd)
+ }
+ }
+ }
+ }, 0)
+ }
+ })
+ }
+
+ handleEditTableCell(target as HTMLTableCellElement)
+
+ return preventEvent()
+ }
+
+ return false
+}
+
+function addRow (td: HTMLTableCellElement, num: number) {
+ const start = parseInt(td.dataset.sourceLine || '0')
+ const end = parseInt(td.dataset.sourceLineEnd || '0')
+
+ if (!checkLineNumber(start, end)) {
+ return
+ }
+
+ const rows = getRows(td)
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const refText = getLineContent(hr.start)
+ const cols = escapedSplit(refText)
+ const columns = cols.map((str) => str.replace(/\S/g, '-'))
+
+ const str = columnsToStr(columns, refText)
+
+ const strs = Array.from({ length: Math.abs(num) }, () => str).join('\n')
+
+ const content = getLineContent(start)
+ const text = num > 0 ? `${content}\n${strs}` : `${strs}\n${content}`
+
+ replaceLine(start, text)
+}
+
+function deleteRow (td: HTMLTableCellElement) {
+ const start = parseInt(td.dataset.sourceLine || '0')
+ const end = parseInt(td.dataset.sourceLineEnd || '0')
+
+ if (!checkLineNumber(start, end)) {
+ return
+ }
+
+ deleteLine(start)
+}
+
+function processColumns (td: HTMLTableCellElement, process: (columns: string[]) => void) {
+ const rows = getRows(td)
+ if (rows.some(({ start, end }) => !checkLineNumber(start, end))) {
+ return
+ }
+
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const refText = getLineContent(hr.start)
+
+ const _editor = editor.getEditor()
+ const monaco = editor.getMonaco()
+
+ const _replaceLine = editWrapper((line: number, text: string) => {
+ const length = editor.getEditor().getModel()!.getLineLength(line)
+ _editor.executeEdits('', [
+ {
+ range: new (monaco.Range)(line, 1, line, length + 1),
+ text,
+ forceMoveMarkers: true
+ }
+ ])
+ _editor.setPosition(new monaco.Position(line, text.length + 1))
+ })
+
+ rows.forEach((row) => {
+ const { start } = row
+
+ const content = getLineContent(start)
+ const columns = escapedSplit(content)
+
+ process(columns)
+
+ _replaceLine(start, columnsToStr(columns, refText))
+ })
+
+ _editor.focus()
+}
+
+function alignCol (td: HTMLTableCellElement, type: 'left' | 'center' | 'right' | 'normal') {
+ const rows = getRows(td)
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const content = getLineContent(hr.start)
+ const columns = escapedSplit(content)
+ const cellIndex = getCellIndex(td)
+
+ let val = (columns[cellIndex] || '').replace(/^\s*:*|:*\s*$/g, '')
+
+ switch (type) {
+ case 'left':
+ val = ':' + val
+ break
+ case 'center':
+ val = ':' + val + ':'
+ break
+ case 'right':
+ val = val + ':'
+ break
+ }
+
+ columns[cellIndex] = ` ${val} `
+ replaceLine(hr.start, columnsToStr(columns, content))
+}
+
+function addCol (td: HTMLTableCellElement, num: number) {
+ const offset = num > 0 ? 1 : 0
+ const cellIndex = getCellIndex(td)
+ const arr = Array.from({ length: Math.abs(num) }, () => ' -- ')
+
+ processColumns(td, columns => {
+ if (cellIndex > columns.length - 1 || cellIndex < 0) {
+ return
+ }
+
+ columns.splice(cellIndex + offset, 0, ...arr)
+ })
+}
+
+function deleteCol (td: HTMLTableCellElement) {
+ const cellIndex = getCellIndex(td)
+ processColumns(td, columns => {
+ columns.splice(cellIndex, 1)
+ })
+}
+
+function sortCol (td: HTMLTableCellElement, oldIndex: number, newIndex: number) {
+ processColumns(td, columns => {
+ if (columns.length - 1 < Math.max(oldIndex, newIndex)) {
+ return
+ }
+
+ const text = columns[oldIndex]
+ columns.splice(oldIndex, 1)
+ columns.splice(newIndex, 0, text)
+ })
+}
+
+function sortRow (td: HTMLTableCellElement, oldIndex: number, newIndex: number) {
+ const rows = orderBy(getRows(td).filter(x => x.type === 'body'), x => x.start)
+ if (rows.length - 1 < Math.max(oldIndex, newIndex)) {
+ return
+ }
+
+ if (rows.some(({ start, end }) => !checkLineNumber(start, end))) {
+ return
+ }
+
+ const oldLine = rows[oldIndex].start
+ const newLine = rows[newIndex].start
+
+ const content = getLineContent(oldLine)
+ deleteLine(oldLine)
+ const prevContent = getLineContent(newLine)
+ replaceLine(newLine, `${content}\n${prevContent}`)
+}
+
+function toggleSortMode (td: HTMLTableCellElement, flag: boolean) {
+ const table: (HTMLElement & { colSortable?: Sortable, rowSortable?: Sortable }) | null | undefined = td.parentElement?.parentElement?.parentElement
+ if (!table || table.tagName !== 'TABLE') {
+ return
+ }
+
+ logger.debug('toggleSortMode', flag)
+
+ const theadFirstTr = table.querySelector('thead > tr')
+ const tbody = table.querySelector('tbody')
+
+ const clean = () => {
+ logger.debug('toggleSortMode', 'clean')
+ table.onblur = null
+ table.onkeydown = null
+ table.removeAttribute(tableSortMode)
+ table.colSortable?.destroy()
+ delete table.colSortable
+ table.rowSortable?.destroy()
+ table.blur()
+ delete table.rowSortable
+ }
+
+ if (flag && theadFirstTr && tbody) {
+ clean()
+
+ // restore origin order for vue vnode
+ const restoreOrder = (sortable: Sortable, oldIndex: number, newIndex: number) => {
+ const arr = sortable.toArray()
+ const id = arr[newIndex]
+ arr.splice(newIndex, 1)
+ arr.splice(oldIndex, 0, id)
+ sortable.sort(arr)
+ }
+
+ table.colSortable = Sortable.create(theadFirstTr, {
+ animation: 200,
+ direction: 'horizontal',
+ dataIdAttr: DOM_ATTR_NAME.TOKEN_IDX,
+ onEnd: ({ oldIndex, newIndex }) => {
+ if (typeof oldIndex === 'number' && typeof newIndex === 'number' && oldIndex !== newIndex) {
+ restoreOrder(table.colSortable!, oldIndex, newIndex)
+ sortCol(td, oldIndex, newIndex)
+ renderImmediately()
+ nextTick(() => toggleSortMode(td, true))
+ }
+ }
+ })
+
+ table.rowSortable = Sortable.create(tbody, {
+ animation: 200,
+ direction: 'vertical',
+ handle: 'td:first-of-type',
+ dataIdAttr: DOM_ATTR_NAME.TOKEN_IDX,
+ onEnd: ({ oldIndex, newIndex }) => {
+ if (typeof oldIndex === 'number' && typeof newIndex === 'number' && oldIndex !== newIndex) {
+ restoreOrder(table.rowSortable!, oldIndex, newIndex)
+ sortRow(td, oldIndex, newIndex)
+ renderImmediately()
+ nextTick(() => toggleSortMode(td, true))
+ }
+ }
+ })
+
+ table.tabIndex = -1
+
+ table.onblur = () => {
+ toggleSortMode(td, false)
+ }
+
+ table.onkeydown = (e) => {
+ if (e.key === 'Escape') {
+ toggleSortMode(td, false)
+ }
+ }
+
+ table.setAttribute(tableSortMode, 'true')
+ table.focus()
+ } else {
+ clean()
+ }
+}
+
+function sortRows (td: HTMLTableCellElement, order: 'asc' | 'desc') {
+ const rows = getRows(td).filter(x => x.type === 'body')
+ const cellIndex = getCellIndex(td)
+ const contents = rows.map(row => {
+ const text = getLineContent(row.start)
+ return {
+ sortBy: escapedSplit(text)[cellIndex],
+ text,
+ }
+ })
+
+ orderBy(contents, x => {
+ const number = parseFloat(x.sortBy)
+ if (!isNaN(number) && isFinite(number)) {
+ return number.toFixed(12).padStart(20) + x.sortBy
+ }
+
+ return x.sortBy
+ }, order).forEach(({ text }, i) => {
+ replaceLine(rows[i].start, text)
+ })
+}
+
+const insertNums = reactive({
+ colLeft: 1,
+ colRight: 1,
+ rowTop: 1,
+ rowBottom: 1,
+})
+
+export default {
+ name: 'markdown-table',
+ register: (ctx) => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body table.small td,
+ .markdown-view .markdown-body table.small th {
+ padding: 3px 6px;
+ font-size: 14px;
+ line-height: 1.3;
+ }
+
+ @media screen {
+ .markdown-view .markdown-body .table-wrapper {
+ overflow-x: auto;
+ margin-bottom: 16px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table {
+ margin-bottom: 6px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tr {
+ scroll-margin: 2px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table th {
+ white-space: nowrap;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table td:hover,
+ .markdown-view .markdown-body .table-wrapper > table th:hover {
+ background: var(--g-color-85);
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tr:hover {
+ outline: 1px #b3833b dashed;
+ outline-offset: -1px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tbody {
+ counter-reset: tr-number;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tbody:hover td:first-child:before {
+ counter-increment: tr-number;
+ content: counter(tr-number);
+ position: absolute;
+ right: 100%;
+ padding-right: 5px;
+ color: #999;
+ font-family: monospace;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode],
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] tr {
+ outline: none;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] td:hover,
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] th:hover {
+ background: initial;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] thead tr:first-of-type th {
+ background: var(--g-color-86);
+ cursor: ew-resize;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] tbody tr td:first-of-type {
+ background: var(--g-color-86);
+ cursor: ns-resize;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] .sortable-ghost {
+ opacity: 0.5;
+ }
+ }
+ `)
+
+ ctx.theme.addStyles(`
+ .plugin-table-cell-edit-insert-nums {
+ display: flex;
+ align-items: center;
+ }
+
+ .plugin-table-cell-edit-insert-nums > input {
+ margin-left: 10px !important;
+ font-size: 12px !important;
+ padding: 0 2px !important;
+ width: 3em !important;
+ text-align: center !important;
+ background: rgba(var(--g-color-0-rgb), 0.1) !important;
+ margin-top: -4px !important;
+ margin-bottom: -4px !important;
+ }
+ `)
+
+ ctx.markdown.registerPlugin(md => {
+ md.renderer.rules.table_open = (tokens, idx, options, _, slf) => {
+ const table = slf.renderToken(tokens, idx, options)
+ return {
+ node: ctx.lib.vue.h('div', {
+ class: 'table-wrapper'
+ }, table),
+ parent: table
+ } as any
+ }
+
+ md.renderer.rules.td_open = injectClass
+ md.renderer.rules.th_open = injectClass
+ })
+
+ ctx.registerHook('VIEW_ELEMENT_DBCLICK', ({ e }) => handleClick(e, false))
+ ctx.registerHook('VIEW_ELEMENT_CLICK', ({ e }) => handleClick(e, true))
+ ctx.registerHook('VIEW_RENDERED', () => {
+ if (ctx.args.FLAG_READONLY) {
+ return
+ }
+
+ const view = ctx.view.getViewDom()
+ view?.querySelectorAll('.yank-table-cell').forEach(td => {
+ (td as HTMLElement).title = t('table-cell-edit.db-click-edit')
+ })
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node }) => {
+ // remove table style: width, height
+ if (node.tagName === 'TABLE') {
+ node.style.width = ''
+ node.style.height = ''
+ }
+ })
+
+ ctx.view.tapContextMenus((menus, e) => {
+ if (ctx.args.FLAG_READONLY) {
+ return
+ }
+
+ const target = e.target as HTMLTableCellElement
+ const tagName = target.tagName
+ if ((tagName === 'TD' || tagName === 'TH') && target.classList.contains(cellClassName)) {
+ const rows = getRows(target)
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const columns = escapedSplit(ctx.editor.getLineContent(hr.start))
+ const cellIndex = getCellIndex(target)
+ const styleText = (columns[cellIndex] || '').trim()
+
+ if (!styleText) {
+ const msg = 'Incorrect table format'
+ ctx.ui.useToast().show('warning', msg)
+ throw new Error(msg)
+ }
+
+ const buildInput = (key: keyof typeof insertNums) => ctx.lib.vue.h('input', {
+ value: insertNums[key],
+ type: 'number',
+ min: 1,
+ max: 99,
+ step: 1,
+ onInput: (e: any) => { insertNums[key] = e.target.value },
+ onClick: (e: any) => { e.stopPropagation() },
+ onKeyup: (e: any) => { if (e.keyCode === 13) { e.target.parentNode.click(); e.stopPropagation() } }
+ })
+
+ const editRowMenu: Components.ContextMenu.Item[] = tagName === 'TD' ? [
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.add-row-above',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-row-above'),
+ buildInput('rowTop')
+ ]),
+ onClick: () => addRow(target, -(insertNums.rowTop || 1)),
+ },
+ {
+ id: 'plugin.table.cell-edit.add-row-below',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-row-below'),
+ buildInput('rowBottom')
+ ]),
+ onClick: () => addRow(target, insertNums.rowBottom || 1),
+ },
+ {
+ id: 'plugin.table.cell-edit.delete-row',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.delete-row'),
+ hidden: rows.length < 4,
+ onClick: () => deleteRow(target)
+ },
+ ] : []
+
+ menus.push(
+ {
+ id: 'plugin.table.cell-edit.quick-edit',
+ type: 'normal' as any,
+ label: ctx.i18n.t('table-cell-edit.context-menu.quick-edit'),
+ onClick: () => {
+ handleClick(e, false)
+ }
+ },
+ {
+ id: 'plugin.table.cell-edit.edit',
+ type: 'normal' as any,
+ label: ctx.i18n.t('table-cell-edit.context-menu.edit'),
+ ellipsis: true,
+ onClick: () => {
+ handleClick(e, true)
+ }
+ },
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.sort-mode',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.sort-mode'),
+ onClick: () => {
+ toggleSortMode(target, true)
+ }
+ },
+ {
+ id: 'plugin.table.cell-edit.sort-asc',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.sort-asc'),
+ onClick: () => {
+ sortRows(target, 'asc')
+ }
+ },
+ {
+ id: 'plugin.table.cell-edit.sort-desc',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.sort-desc'),
+ onClick: () => {
+ sortRows(target, 'desc')
+ }
+ },
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.align-left',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-left'),
+ hidden: /^:[^:]*$/.test(styleText),
+ onClick: () => alignCol(target, 'left'),
+ },
+ {
+ id: 'plugin.table.cell-edit.align-center',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-center'),
+ hidden: /^:[^:]*:$/.test(styleText),
+ onClick: () => alignCol(target, 'center'),
+ },
+ {
+ id: 'plugin.table.cell-edit.align-right',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-right'),
+ hidden: /^[^:]*:$/.test(styleText),
+ onClick: () => alignCol(target, 'right'),
+ },
+ {
+ id: 'plugin.table.cell-edit.align-normal',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-normal'),
+ hidden: /^[^:]*$/.test(styleText),
+ onClick: () => alignCol(target, 'normal'),
+ },
+ ...editRowMenu,
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.add-col-left',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-col-left'),
+ buildInput('colLeft')
+ ]),
+ onClick: () => addCol(target, -(insertNums.colLeft || 1))
+ },
+ {
+ id: 'plugin.table.cell-edit.add-col-right',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-col-right'),
+ buildInput('colRight')
+ ]),
+ onClick: () => addCol(target, insertNums.colRight || 1)
+ },
+ {
+ id: 'plugin.table.cell-edit.delete-col',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.delete-col'),
+ hidden: columns.length < 2,
+ onClick: () => deleteCol(target)
+ },
+ )
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-task-list.ts b/src/renderer/plugins/markdown-task-list.ts
index cc6426bf4..33e8cccd6 100644
--- a/src/renderer/plugins/markdown-task-list.ts
+++ b/src/renderer/plugins/markdown-task-list.ts
@@ -7,8 +7,10 @@
// https://github.com/blog/1375-task-lists-in-gfm-issues-pulls-comments
// https://github.com/blog/1825-task-lists-in-all-markdown-documents
+import { h } from 'vue'
import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
+import { DOM_CLASS_NAME } from '@fe/support/args'
let disableCheckboxes = true
@@ -67,12 +69,22 @@ function todoify (token: { children: any[]; content: string | any[] }, TokenCons
function makeCheckbox (token: { content: string | string[] }, TokenConstructor: new (arg0: string, arg1: string, arg2: number) => any) {
const checkbox = new TokenConstructor('html_inline', '', 0)
- const disabledAttr = disableCheckboxes ? ' disabled="" ' : ' '
+
+ const props = {
+ class: DOM_CLASS_NAME.TASK_LIST_ITEM_CHECKBOX,
+ type: 'checkbox',
+ disabled: disableCheckboxes,
+ }
+
if (token.content.indexOf('[ ] ') === 0) {
- checkbox.content = ''
+ const checked = false
+ checkbox.contentVNode = h('input', { ...props, checked, 'data-checked': String(checked) })
} else if (token.content.indexOf('[x] ') === 0 || token.content.indexOf('[X] ') === 0) {
- checkbox.content = ''
+ const checked = true
+ checkbox.contentVNode = h('input', { ...props, checked, 'data-checked': String(checked) })
}
+
+ checkbox.content = token.content
return checkbox
}
@@ -89,5 +101,16 @@ export default {
name: 'markdown-task-list',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin, { enabled: true })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node }) => {
+ if (node.classList.contains(DOM_CLASS_NAME.TASK_LIST_ITEM_CHECKBOX)) {
+ node.setAttribute('disabled', 'disabled')
+ if (node.dataset.checked === 'true') {
+ node.setAttribute('checked', 'checked')
+ } else {
+ node.removeAttribute('checked')
+ }
+ }
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-toc.ts b/src/renderer/plugins/markdown-toc.ts
index 0278b61a3..837c0b809 100644
--- a/src/renderer/plugins/markdown-toc.ts
+++ b/src/renderer/plugins/markdown-toc.ts
@@ -1,13 +1,12 @@
// https://github.com/Oktavilla/markdown-it-table-of-contents
+import { h } from 'vue'
import Markdown from 'markdown-it'
import StateInline from 'markdown-it/lib/rules_inline/state_inline'
-import { getKeyLabel } from '@fe/context/shortcut'
-import { Plugin } from '@fe/context/plugin'
+import { getKeyLabel } from '@fe/core/keybinding'
+import ctx, { Plugin } from '@fe/context'
-import { injectLineNumbers } from './markdown-source-line'
-
-const slugify = (s: string) => 'h-' + encodeURIComponent(String(s).trim().toLowerCase().replace(/\s+/g, '-'))
+const slugify = (s: string) => String(s).trim().replace(/\s+/g, '-')
const defaults = {
level: [2, 3],
@@ -24,7 +23,7 @@ const defaults = {
const MarkdownItPlugin = (md: Markdown, o: any) => {
const options = Object.assign({}, defaults, o)
const tocRegexp = options.markerPattern
- let gstate: any
+ let gTokens: any[]
function toc (state: StateInline, silent: any) {
let match
@@ -45,12 +44,12 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
return false
}
- if (match.length > 1) { // 有自定义参数进来
+ if (match.length > 1) { // custom params.
try {
const ext = JSON.parse(match[1].replace(/(['"])?([a-z0-9A-Z_]+)(['"])?:/g, '"$2": '))
Object.assign(options, defaults, o, ext)
} catch (error) {
- console.log('参数解析错误', match)
+ console.log('parse params error', match)
}
} else {
Object.assign(options, defaults, o)
@@ -109,12 +108,14 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
}
}
- // 给标题加上 id
+ // Add id to heading.
const slug = options.slugify(heading.content)
- buffer = ``
- buffer += typeof options.format === 'function' ? options.format(heading.content) : heading.content
+ buffer = ``
+ buffer += typeof options.format === 'function'
+ ? options.format(heading.content)
+ : heading.content.replaceAll('<', '<').replaceAll('>', '>')
buffer += ''
i++
}
@@ -124,6 +125,10 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
}
md.renderer.rules.toc_body = function () {
+ if (!gTokens) {
+ return
+ }
+
let tocBody = ''
if (options.forceFullToc) {
@@ -143,24 +148,28 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
*/
let pos = 0
- const tokenLength = gstate && gstate.tokens && gstate.tokens.length
+ const tokenLength = gTokens.length
while (pos < tokenLength) {
- const tocHierarchy = renderChildrenTokens(pos, gstate.tokens)
+ const tocHierarchy = renderChildrenTokens(pos, gTokens)
pos = tocHierarchy[0]
tocBody += tocHierarchy[1]
}
} else {
- tocBody = renderChildrenTokens(0, gstate.tokens)[1]
+ tocBody = renderChildrenTokens(0, gTokens)[1]
}
- return ``
+ const html = `
+ ${options.containerHeaderHtml}
+ ${tocBody}
+ ${options.containerFooterHtml}
+ `
+
+ return h('div', { key: html, class: options.containerClass, innerHTML: html }) as any
}
+ const headTitle = getKeyLabel('CtrlCmd') + ' + ' + ctx.i18n.t('click-to-copy-link')
+
md.renderer.rules.heading_open = function (tokens, idx, opt, env, slf) {
const header = tokens[idx]
const headContent = tokens[idx + 1]
@@ -171,15 +180,22 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
}
if (header.attrIndex('title') < 0) {
- header.attrSet('title', getKeyLabel('CtrlCmd') + ' + 单击复制链接')
+ header.attrSet('title', headTitle)
}
- return injectLineNumbers(tokens, idx, opt, env, slf)
+ header.attrSet('data-tag', header.tag)
+
+ return slf.renderToken(tokens, idx, opt)
}
// Catch all the tokens for iteration later
md.core.ruler.push('grab_state', function (state) {
- gstate = state
+ // only heading close and heading content
+ const maxIdx = state.tokens.length - 1
+ gTokens = state.tokens.filter((token: any, i: number, arr: any[]) => {
+ return token.type === 'heading_close' ||
+ (i < maxIdx && arr[i + 1].type === 'heading_close' && token.type === 'inline')
+ })
return true
})
@@ -190,7 +206,7 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
export default {
name: 'markdown-toc',
register: ctx => {
- ctx.theme.addStyles(`
+ ctx.view.addStyles(`
.markdown-view .markdown-body .table-of-contents ol {
counter-reset: ol-number;
list-style-type: none;
@@ -211,6 +227,15 @@ export default {
content: counter(ol-number) ". ";
}
`)
+
ctx.markdown.registerPlugin(MarkdownItPlugin)
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ [toc] Table of content', insertText: '[toc]{type: "${1|ul,ol|}", level: [2,3]}', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-wiki-links/index.ts b/src/renderer/plugins/markdown-wiki-links/index.ts
new file mode 100644
index 000000000..0a609c545
--- /dev/null
+++ b/src/renderer/plugins/markdown-wiki-links/index.ts
@@ -0,0 +1,77 @@
+import { Plugin } from '@fe/context'
+import { RULE_NAME, wikiLinks } from './lib'
+import workerIndexerUrl from './worker-indexer?worker&url'
+
+export default {
+ name: 'markdown-wiki-links',
+ register: ctx => {
+ ctx.markdown.registerPlugin(md => {
+ md.inline.ruler.after('link', RULE_NAME, wikiLinks)
+ })
+
+ ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
+ editor.onDidChangeCursorPosition(async e => {
+ // debugger
+ if (e.source === 'keyboard' && e.reason === 0) {
+ // delay to next tick to avoid issue on Windows
+ await ctx.utils.sleep(0)
+
+ const prevStr = editor.getModel()!.getValueInRange({
+ startLineNumber: e.position.lineNumber,
+ startColumn: e.position.column - 2,
+ endLineNumber: e.position.lineNumber,
+ endColumn: e.position.column,
+ })
+
+ const nextStr = editor.getModel()!.getValueInRange({
+ startLineNumber: e.position.lineNumber,
+ startColumn: e.position.column,
+ endLineNumber: e.position.lineNumber,
+ endColumn: e.position.column + 2,
+ })
+
+ if (prevStr === '【【') {
+ // replace 【【 to [[]]
+ editor.pushUndoStop()
+ editor.executeEdits(RULE_NAME, [{
+ range: {
+ startLineNumber: e.position.lineNumber,
+ startColumn: e.position.column - 2,
+ endLineNumber: e.position.lineNumber,
+ endColumn: e.position.column + (nextStr === '】】' ? 2 : 0),
+ },
+ text: '[[]]',
+ }], [
+ new monaco.Selection(
+ e.position.lineNumber,
+ e.position.column,
+ e.position.lineNumber,
+ e.position.column,
+ ),
+ ])
+ editor.pushUndoStop()
+
+ // trigger completion
+ editor.trigger(RULE_NAME, 'editor.action.triggerSuggest', {})
+ }
+ }
+ })
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ items.push(
+ { language: 'markdown', label: '/ [[]] Wiki Link', insertText: '[[$1]]', command: { id: 'editor.action.triggerSuggest', title: '' } },
+ )
+ })
+
+ ctx.indexer.importScriptsToWorker(new URL(workerIndexerUrl, import.meta.url))
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys }) => {
+ if (changedKeys.includes('render.md-wiki-links')) {
+ ctx.indexer.rebuildCurrentRepo()
+ }
+ })
+
+ return { mdRuleWikiLinks: wikiLinks }
+ }
+} satisfies Plugin
diff --git a/src/renderer/plugins/markdown-wiki-links/lib.ts b/src/renderer/plugins/markdown-wiki-links/lib.ts
new file mode 100644
index 000000000..dc26f04f4
--- /dev/null
+++ b/src/renderer/plugins/markdown-wiki-links/lib.ts
@@ -0,0 +1,90 @@
+import { DOM_ATTR_NAME } from '@fe/support/args'
+import type StateInline from 'markdown-it/lib/rules_inline/state_inline'
+
+const reMatch = /^([^[#|]*)?(?:#([^#|]*))?(?:\|([^\]]*))?$/
+const reExternalLink = /^[a-zA-Z]{1,8}:\/\/.*/
+const rePos = /(:\d{1,6},?\d{0,6})$/
+
+export const RULE_NAME = 'wiki-links'
+
+export function wikiLinks (state: StateInline, silent?: boolean) {
+ const isImage = state.src.charCodeAt(state.pos) === 0x21/* ! */
+
+ const offset = isImage
+ ? 3 // ![[
+ : 2 // [[
+
+ // check [[
+ if (state.src.charCodeAt(state.pos + offset - 2) !== 0x5B/* [ */ || state.src.charCodeAt(state.pos + offset - 1) !== 0x5B/* [ */) {
+ return false
+ }
+
+ const endPos = state.src.indexOf(']]', state.pos + offset)
+ if (endPos === -1 || endPos === state.pos + offset) {
+ return false
+ }
+
+ const content = state.src.slice(state.pos + offset, endPos)
+ const parts = content.match(reMatch)
+ if (!parts) {
+ return false
+ }
+
+ let link = (parts[1] || '').trim()
+ const hash = parts[2] || ''
+ const label = parts[3] || ''
+
+ const hashStr = hash ? `#${hash}` : ''
+
+ let url = link + hashStr
+ let text = label || url
+ let isAnchor = false
+
+ // internal link
+ if (!reExternalLink.test(link)) {
+ let posStr = ''
+ const posMatch = link.match(rePos)
+ if (posMatch) {
+ link = link.replace(rePos, '')
+ posStr = posMatch[1]
+ }
+
+ const fileName = link.split('/').pop()
+ text = label || (fileName ? (fileName + posStr + hashStr) : url)
+
+ if (!link) {
+ url = posStr + hashStr
+ text = label || hash || url
+ isAnchor = true
+ }
+ }
+
+ if (!silent) {
+ if (isImage) {
+ const attrs: [string, string][] = [
+ ['src', url],
+ [DOM_ATTR_NAME.WIKI_RESOURCE, 'true'],
+ ['alt', text],
+ ]
+
+ state.push('image', 'img', 0).attrs = attrs
+ } else {
+ const attrs: [string, string][] = [
+ ['href', url],
+ [DOM_ATTR_NAME.WIKI_LINK, 'true'],
+ ]
+
+ if (isAnchor) {
+ attrs.push([DOM_ATTR_NAME.IS_ANCHOR, 'true'])
+ }
+
+ state.push('link_open', 'a', 1).attrs = attrs
+ state.push('text', '', 0).content = text
+ state.push('link_close', 'a', -1)
+ }
+ }
+
+ state.pos = endPos + 2 // ]]
+
+ return true
+}
diff --git a/src/renderer/plugins/markdown-wiki-links/worker-indexer.ts b/src/renderer/plugins/markdown-wiki-links/worker-indexer.ts
new file mode 100644
index 000000000..10fab376e
--- /dev/null
+++ b/src/renderer/plugins/markdown-wiki-links/worker-indexer.ts
@@ -0,0 +1,18 @@
+import { RULE_NAME, wikiLinks } from './lib'
+import type { IndexerWorkerCtx } from '@fe/others/indexer-worker'
+
+const ctx: IndexerWorkerCtx = self.ctx
+
+ctx.markdown.use(md => {
+ md.inline.ruler.after('link', RULE_NAME, wikiLinks)
+})
+
+ctx.registerHook('WORKER_INDEXER_BEFORE_START_WATCH', async () => {
+ const enableWikiLinks = await ctx.bridgeClient.call.ctx.setting.getSetting('render.md-wiki-links', true as any)
+
+ if (enableWikiLinks) {
+ ctx.markdown.enable([RULE_NAME], true)
+ } else {
+ ctx.markdown.disable([RULE_NAME], true)
+ }
+})
diff --git a/src/renderer/plugins/media-player.ts b/src/renderer/plugins/media-player.ts
new file mode 100644
index 000000000..341900f91
--- /dev/null
+++ b/src/renderer/plugins/media-player.ts
@@ -0,0 +1,128 @@
+import { defineComponent, h, ref, watchEffect } from 'vue'
+import mime from 'mime'
+import type { Plugin } from '@fe/context'
+import store from '@fe/support/store'
+import { getAttachmentURL } from '@fe/services/base'
+import { sleep } from '@fe/utils'
+import type { Doc } from '@fe/types'
+
+import { isElectron } from '@fe/support/env'
+
+function isMediaFile (doc?: Doc | null): 'video' | 'audio' | false {
+ if (!doc) {
+ return false
+ }
+
+ if (doc.plain) {
+ return false
+ }
+
+ const fileMime = mime.getType(doc.name)
+ if (!fileMime) {
+ return false
+ }
+
+ if (fileMime.startsWith('video/')) {
+ return 'video'
+ }
+
+ if (fileMime.startsWith('audio/')) {
+ return 'audio'
+ }
+
+ return false
+}
+
+const MediaPlayer = defineComponent({
+ setup () {
+ const src = ref('')
+ const type = ref<'video' | 'audio' | false>(false)
+
+ watchEffect(async () => {
+ const doc = store.state.currentFile
+ type.value = false
+ src.value = ''
+ await sleep(0)
+
+ if (doc) {
+ type.value = isMediaFile(doc)
+
+ if (isElectron && doc.absolutePath) {
+ src.value = 'file://' + doc.absolutePath
+ } else {
+ src.value = getAttachmentURL(doc)
+ }
+ }
+ })
+
+ function onLeavepictureinpicture (e: Event) {
+ const target = e.target as HTMLMediaElement
+ if (!target.isConnected) {
+ target.pause()
+ }
+ }
+
+ return () => src.value ? h(
+ 'div',
+ { style: 'width: 100%; height: 100%; display: flex; align-items: center; justify-content: center' },
+ type.value === 'video'
+ ? h('video', { src: src.value, controls: true, onLeavepictureinpicture, style: 'width: 100%; height: 100%; object-fit: contain' })
+ : type.value === 'audio'
+ ? h('audio', { src: src.value, controls: true })
+ : ''
+ ) : null
+ }
+})
+
+export default {
+ name: 'media-player',
+ register: ctx => {
+ ctx.editor.registerCustomEditor({
+ name: 'image-player',
+ displayName: 'Image Viewer',
+ hiddenPreview: true,
+ when ({ doc }) {
+ return !!isMediaFile(doc)
+ },
+ component: MediaPlayer,
+ })
+
+ type XHTMLMediaElement = HTMLMediaElement & { _setAudioPreload?: (isInView: boolean) => void }
+
+ let observer: IntersectionObserver | null = null
+
+ function setAudioPreload (this: XHTMLMediaElement, isInView: boolean) {
+ if (isInView && this._setAudioPreload) {
+ this.preload = 'metadata'
+ delete this._setAudioPreload
+ observer?.unobserve(this)
+ }
+ }
+
+ function cleanObserver () {
+ observer?.disconnect()
+ observer = null
+ }
+
+ ctx.registerHook('VIEW_RENDERED', () => {
+ cleanObserver()
+
+ const medias = ctx.view.getViewDom()?.querySelectorAll('audio')
+ if (medias && medias.length > 0) {
+ observer = new IntersectionObserver(entries => {
+ entries.forEach(entry => {
+ const el = entry.target as XHTMLMediaElement
+ el._setAudioPreload?.(entry.isIntersecting)
+ })
+ })
+
+ medias.forEach((media: XHTMLMediaElement) => {
+ if (media.preload === 'none') {
+ media._setAudioPreload = ctx.lib.lodash.debounce(setAudioPreload, 400, { leading: false, trailing: true })
+ observer!.observe(media)
+ }
+ })
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/misc.ts b/src/renderer/plugins/misc.ts
new file mode 100644
index 000000000..aab23eb25
--- /dev/null
+++ b/src/renderer/plugins/misc.ts
@@ -0,0 +1,22 @@
+import { Plugin } from '@fe/context'
+
+export default {
+ name: 'misc',
+ register: ctx => {
+ ctx.markdown.registerPlugin(md => {
+ md.renderer.rules.paragraph_open = (tokens, idx, options, env, self) => {
+ // auto recognize block image
+ if (
+ tokens[idx + 1]?.type === 'inline' &&
+ tokens[idx + 2]?.type === 'paragraph_close' &&
+ tokens[idx + 1]?.children?.length === 1 &&
+ (tokens[idx + 1]?.children?.[0]?.type === 'image' || tokens[idx + 1]?.children?.[0]?.type === 'media')
+ ) {
+ tokens[idx + 1]?.children?.[0].attrSet(ctx.args.DOM_ATTR_NAME.ONLY_CHILD, 'true')
+ }
+
+ return self.renderToken(tokens, idx, options)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/preview-font.ts b/src/renderer/plugins/preview-font.ts
new file mode 100644
index 000000000..c816e5a34
--- /dev/null
+++ b/src/renderer/plugins/preview-font.ts
@@ -0,0 +1,68 @@
+import { h, ref } from 'vue'
+import type { Plugin } from '@fe/context'
+import type { Components } from '@fe/types'
+
+export default {
+ name: 'preview-font',
+ register: ctx => {
+ const defaultFontSize = 16
+ const storageFontSizeKey = 'plugin.preview-font.size'
+ const previewFontSize = ref(ctx.utils.storage.get(storageFontSizeKey, defaultFontSize))
+
+ function updateMarkdownBodyDom () {
+ const fontSize = previewFontSize.value
+ ctx.storage.set(storageFontSizeKey, fontSize)
+
+ ctx.view.getRenderIframe().then(iframe => {
+ const markdownBody = iframe.contentDocument?.querySelector(`.${ctx.args.DOM_CLASS_NAME.PREVIEW_MARKDOWN_BODY}`) as HTMLElement
+ if (markdownBody) {
+ markdownBody.style.fontSize = `${fontSize}px`
+ const fontFamily = ctx.setting.getSetting('view.default-previewer-font-family')
+ if (fontFamily) {
+ markdownBody.style.fontFamily = fontFamily
+ } else {
+ markdownBody.style.removeProperty('font-family')
+ }
+ }
+ })
+ }
+
+ function customFontSize (): Components.ControlCenter.Item {
+ ctx.lib.vue.watchEffect(updateMarkdownBodyDom)
+
+ return {
+ type: 'custom',
+ order: 1024,
+ hidden: !ctx.store.state.showView || ctx.store.state.previewer !== 'default',
+ component: () => h('div', { style: 'width: 100%; display: flex; justify-content: center; align-items: center; height: 40px; padding: 0 10px;' }, [
+ h('span', { style: 'margin-right: 8px; cursor: default', onClick: () => { previewFontSize.value = defaultFontSize } }, [
+ 'A',
+ h('span', { style: 'font-size: 12px;' }, 'A')
+ ]),
+ h('input', {
+ style: 'width: 100%;',
+ type: 'range',
+ min: 12,
+ max: 40,
+ step: 1,
+ value: previewFontSize.value,
+ onInput: (e: any) => {
+ previewFontSize.value = parseInt(e.target.value)
+ }
+ }),
+ h('output', { style: 'margin-left: 8px; font-size: 14px; font-variant-numeric: tabular-nums;' }, previewFontSize.value),
+ ])
+ }
+ }
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.switch.items.push(customFontSize())
+ })
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys }) => {
+ if (changedKeys.includes('view.default-previewer-font-family')) {
+ updateMarkdownBodyDom()
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/record-recent-document.ts b/src/renderer/plugins/record-recent-document.ts
new file mode 100644
index 000000000..f527cc808
--- /dev/null
+++ b/src/renderer/plugins/record-recent-document.ts
@@ -0,0 +1,27 @@
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'record-recent-document',
+ register: (ctx) => {
+ // only support electron
+ if (!ctx.env.isElectron) {
+ return
+ }
+
+ // record recent document after markdown file saved
+ ctx.registerHook('DOC_SAVED', ({ doc }) => {
+ setTimeout(() => {
+ if (ctx.doc.isMarkdownFile(doc) && doc.absolutePath) {
+ let path = doc.absolutePath
+
+ // replace '/' to '\' on windows
+ if (ctx.env.isWindows) {
+ path = path.replaceAll('/', '\\')
+ }
+
+ ctx.env.getElectronRemote().app.addRecentDocument(path)
+ }
+ }, 0)
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/share-preview.tsx b/src/renderer/plugins/share-preview.tsx
new file mode 100644
index 000000000..6fb9d7d09
--- /dev/null
+++ b/src/renderer/plugins/share-preview.tsx
@@ -0,0 +1,153 @@
+import type { Plugin } from '@fe/context'
+import { FLAG_MAS } from '@fe/support/args'
+
+export default {
+ name: 'share-preview',
+ register: (ctx) => {
+ ctx.registerHook('STARTUP', () => {
+ if (ctx.args.MODE === 'share-preview') {
+ ctx.store.watch(() => ctx.store.state.presentation, val => {
+ if (!val) {
+ ctx.store.state.presentation = true
+ }
+ }, { immediate: true })
+ }
+ })
+
+ if (FLAG_MAS) {
+ return
+ }
+
+ const link = ctx.lib.vue.ref('')
+ const ip = ctx.lib.vue.ref('')
+
+ const panel = ctx.lib.vue.defineComponent({
+ setup () {
+ const expire = ctx.lib.vue.ref('2h')
+ const ips = ctx.lib.vue.ref([] as string[])
+
+ ctx.lib.vue.onMounted(async () => {
+ ips.value = await ctx.api.rpc(`
+ const ip = require('ip')
+ const os = require('os')
+ return Object.values(os.networkInterfaces())
+ .flat()
+ .map(x => x.address)
+ .filter(x => ip.isV4Format(x) && !ip.isLoopback(x))
+ `)
+ if (!ips.value.includes(ip.value)) {
+ ip.value = ips.value[0]
+ }
+ })
+
+ ctx.lib.vue.watch([expire, ip], async ([expire, ip]) => {
+ link.value = ''
+ const currentFile = ctx.store.state.currentFile
+ if (!currentFile) {
+ return
+ }
+
+ if (!expire || !ip) {
+ return
+ }
+
+ const token = await ctx.api.rpc(`return require('./jwt').getToken({ role: 'guest' }, '${expire}')`)
+ const port = location.port || ctx.args.$args().get('port') || '80'
+ const url = new URL(`http://${ip}:${port}`)
+ url.searchParams.set('mode', 'share-preview')
+ url.searchParams.set('token', token)
+ url.searchParams.set('init-repo', currentFile.repo)
+ url.searchParams.set('init-file', currentFile.path)
+ link.value = url.toString()
+ }, { immediate: true })
+
+ return () =>
- {{ item.name === '/' ? currentRepoName : item.name }} ({{item.children.length}})
+ :style="`padding-left: ${itemNode.level}em`"
+ @contextmenu.exact.prevent.stop="showContextMenu(itemNode)">
+ ;
+}
+
+db.version(1).stores({
+ documents: '++id, repo, [repo+path]',
+})
+
+export const documents = {
+ getTable () {
+ return db.documents
+ },
+ findByRepoAndPath (repo: string, path: string): Promise {
+ logger.debug('getByRepoAndPath', repo, path)
+ return db.documents.where({ repo, path }).first()
+ },
+ async findAllMtimeMsByRepo (repo: string): Promise> {
+ logger.debug('findAllMtimeMsByRepo', repo)
+ const map = new Map()
+ await db.documents.where({ repo }).each(doc => {
+ map.set(doc.path, { id: doc.id, mtimeMs: doc.mtimeMs })
+ })
+ return map
+ },
+ put (entity: Omit & { id?: number }): Promise {
+ logger.debug('updateOrInsert', entity)
+ return db.documents.put(entity)
+ },
+ bulkPut (items: (Omit & { id?: number })[]): Promise {
+ logger.debug('blukPut', items.length)
+ return db.documents.bulkPut(items, { allKeys: true })
+ },
+ async deleteByRepo (repo: string): Promise {
+ logger.debug('deleteByRepo', repo)
+ const deleted = await db.documents.where({ repo }).delete()
+ logger.debug('deleteByRepo deleted', deleted)
+ return deleted
+ },
+ async deleteUnusedRepo (usedRepos: string[]): Promise {
+ logger.debug('deleteUnusedRepo', usedRepos)
+ const deleted = await db.documents.where('repo').noneOf(usedRepos).delete()
+ logger.debug('deleteUnusedRepo deleted', deleted)
+ return deleted
+ },
+ async deleteUnusedInRepo (repo: string, usedIds: number[]): Promise {
+ logger.debug('deleteUnusedInRepo', repo, usedIds.length)
+ const allIds = await db.documents.where({ repo }).primaryKeys()
+ const toDeleteIds = difference(allIds, usedIds)
+ await db.documents.bulkDelete(toDeleteIds)
+ logger.debug('deleteUnusedInRepo deleted', toDeleteIds.length)
+ return toDeleteIds.length
+ },
+ async deletedByRepoAndPath (repo: string, path: string): Promise {
+ logger.debug('deletedByRepoAndPath', repo, path)
+ const deleted = await db.documents.where({ repo, path }).delete()
+ logger.debug('deletedByRepoAndPath deleted', deleted)
+ return deleted
+ }
+}
+
+export async function removeOldDatabases () {
+ const databases = await Dexie.getDatabaseNames()
+ const oldDatabases = databases.filter(name => name.startsWith(dbPrefix) && name !== dbName)
+ logger.debug('remove old databases', oldDatabases)
+ oldDatabases.forEach(name => Dexie.delete(name))
+}
diff --git a/src/renderer/others/demo.ts b/src/renderer/others/demo.ts
new file mode 100644
index 000000000..a4924e7ea
--- /dev/null
+++ b/src/renderer/others/demo.ts
@@ -0,0 +1,364 @@
+import { setTheme } from '@fe/services/theme'
+import * as storage from '@fe/utils/storage'
+import { FLAG_DEMO } from '@fe/support/args'
+import { useToast } from '@fe/support/ui/toast'
+import { getRenderIframe } from '@fe/services/view'
+import { t } from '@fe/services/i18n'
+
+let settings = {
+ repositories: { test: '/path_test' },
+ shell: 'bash',
+ mark: [
+ { repo: 'test', path: '/TODO.md' }
+ ]
+}
+
+const treeData = {
+ status: 'ok',
+ message: 'success',
+ data: [
+ {
+ name: '/',
+ type: 'dir',
+ path: '/',
+ repo: 'test',
+ level: 1,
+ children: [
+ { name: 'Work', path: '/Work', type: 'dir', repo: 'test', level: 2, children: [{ name: '1.md', path: '/Work/1.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635402958.447, mtime: 1623635402958.447 }, { name: '2.md', path: '/Work/2.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635406528.4639, mtime: 1623635406528.4639 }, { name: '3.md', path: '/Work/3.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635410176.051, mtime: 1623635410177.0498 }] },
+ { name: 'Learn', path: '/Learn', type: 'dir', repo: 'test', level: 2, children: [{ name: 'a.md', path: '/Learn/a.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635423871.2678, mtime: 1623635423871.2678 }, { name: 'b.md', path: '/Learn/b.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635427472.3079, mtime: 1623635427472.3079 }, { name: 'c.md', path: '/Learn/c.md', type: 'file', repo: 'test', level: 3, marked: false, birthtime: 1623635431935.041, mtime: 1623635431935.041 }] },
+ { name: 'TEST.md', path: '/TEST.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635389096.3315, mtime: 1623635389097.3403 },
+ { name: 'TODO.md', path: '/TODO.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635437968.1262, mtime: 1623635437969.1235 },
+ { name: 'Secret.c.md', path: '/Secret.c.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Project.luckysheet', path: '/Project.luckysheet', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Drawio.drawio', path: '/Drawio.drawio', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Reveal-js.md', path: '/Reveal-js.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ { name: 'Markmap.md', path: '/Markmap.md', type: 'file', repo: 'test', level: 2, marked: false, birthtime: 1623635542753.2976, mtime: 1623635542753.2976 },
+ ]
+ }]
+}
+
+const markupContent = `---
+defaultPreviewer: 'Markmap'
+---
+
+# markmap
+
+## Links
+
+- 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 ()
+
+export const registries: RegistryHostname[] = [
+ 'registry.npmjs.org',
+ 'registry.npmmirror.com',
+]
+
+function shouldLoad (extension: Extension) {
+ return extension.enabled && extension.compatible
+}
+
+function changeRegistryOrigin (hostname: RegistryHostname, url: string) {
+ const _url = new URL(url)
+ _url.hostname = hostname
+ return _url.toString()
+}
+
+export function getExtensionPath (id: string, ...paths: string[]) {
+ return path.join(id.replace(/\//g, '$'), ...paths)
+}
+
+export function getInstalledExtensionFileUrl (id: string, filename: string) {
+ if (/https?:\/\//.test(filename)) {
+ return filename
+ }
+
+ return path.join('/extensions', getExtensionPath(id, filename))
+}
+
+export function getLoadStatus (id: string): ExtensionLoadStatus {
+ return loaded.get(id) || { version: undefined, themes: false, plugin: false, style: false, activationTime: 0 }
+}
+
+export function getCompatible (engines?: { 'yank-note': string }): ExtensionCompatible {
+ if (!engines || !engines['yank-note']) {
+ return { value: false, reason: 'Not yank note extension.' }
+ }
+
+ const engineVersion = __APP_VERSION__
+
+ const value = semver.satisfies(engineVersion, engines['yank-note'])
+
+ return {
+ value,
+ reason: value ? 'Compatible' : `Need Yank Note [${engines['yank-note']}].`,
+ }
+}
+
+export function readInfoFromJson (json: any): Omit | null {
+ if (!json || !json.name || !json.version) {
+ return null
+ }
+
+ const language = i18n.getCurrentLanguage().toUpperCase()
+
+ return {
+ id: json.name,
+ version: json.version,
+ license: typeof json.license === 'string' ? json.license : '',
+ author: typeof json.author === 'string'
+ ? parseAuthor(json.author) || { name: '' }
+ : json.author || { name: '' },
+ themes: json.themes || [],
+ requirements: json.requirements || {},
+ main: json.main || '',
+ style: json.style || '',
+ icon: json.icon || '',
+ readmeUrl: json.readmeUrl || '',
+ changelogUrl: json.changelogUrl || '',
+ displayName: json[`displayName_${language}`] || json.displayName || json.name,
+ description: json[`description_${language}`] || json.description || '',
+ compatible: getCompatible(json.engines),
+ origin: json.origin || 'unknown',
+ dist: json.dist || { tarball: '', unpackedSize: 0 },
+ homepage: json.homepage || '',
+ }
+}
+
+export async function getInstalledExtension (id: string): Promise {
+ let json
+
+ try {
+ json = await api.fetchHttp(getInstalledExtensionFileUrl(id, 'package.json'))
+ if (!json.name || !json.version) {
+ throw new Error('Invalid extension package.json')
+ }
+ } catch (error) {
+ logger.error(error)
+ return null
+ }
+
+ const info = readInfoFromJson(json)
+ if (info) {
+ return { ...info, installed: true, origin: FLAG_DEMO ? 'registry' : 'unknown' }
+ }
+
+ return null
+}
+
+export async function getInstalledExtensions () {
+ const extensions: Extension[] = []
+ for (const item of await api.fetchInstalledExtensions()) {
+ const info = await getInstalledExtension(item.id)
+ if (info) {
+ if (info.id !== item.id) {
+ logger.warn(`Extension ${item.id} has been installed but package.json is not valid.`)
+ continue
+ }
+
+ extensions.push({
+ ...info,
+ installed: true,
+ enabled: item.enabled && info.compatible.value,
+ icon: getInstalledExtensionFileUrl(info.id, info.icon),
+ readmeUrl: getInstalledExtensionFileUrl(info.id, 'README.md'),
+ changelogUrl: getInstalledExtensionFileUrl(info.id, 'CHANGELOG.md'),
+ isDev: item.isDev,
+ })
+ }
+ }
+
+ return extensions
+}
+
+export async function getRegistryExtensions (registry: RegistryHostname = 'registry.npmjs.org'): Promise {
+ logger.debug('getRegistryExtensions', registry)
+
+ const registryUrl = `https://${registry}/yank-note-registry`
+ const registryJson = await api.proxyFetch(registryUrl, { timeout: 5000 }).then(r => r.json())
+ const latest = registryJson['dist-tags'].latest
+ const tarballUrl = changeRegistryOrigin(registry, registryJson.versions[latest].dist.tarball)
+
+ const extensions = await api.proxyFetch(tarballUrl, { timeout: 5000 })
+ .then(r => r.arrayBuffer())
+ .then(data => pako.inflate(new Uint8Array(data)))
+ .then(arr => arr.buffer)
+ .then(buffer => untar(buffer))
+ .then(files => files.find((x: any) => x.name === 'package/index.json'))
+ .then(file => new TextDecoder('utf-8').decode(file.buffer))
+ .then(JSON.parse)
+
+ return extensions.map(readInfoFromJson)
+}
+
+export function showManager (id?: string) {
+ getActionHandler('extension.show-manager')(id)
+}
+
+export async function enable (extension: Extension) {
+ await api.enableExtension(extension.id)
+ extension.enabled = true
+ await load(extension)
+ triggerHook('EXTENSION_READY', { extensions: [extension] })
+}
+
+export async function disable (extension: Pick) {
+ await api.disableExtension(extension.id)
+}
+
+export async function uninstall (extension: Pick) {
+ await api.uninstallExtension(extension.id)
+}
+
+export async function abortInstallation () {
+ await api.abortExtensionInstallation()
+}
+
+export async function install (extension: Extension, registry: RegistryHostname = 'registry.npmjs.org') {
+ const url = extension.dist.tarball
+ if (!url) {
+ throw new Error('No dist url')
+ }
+
+ await api.installExtension(extension.id, changeRegistryOrigin(registry, url))
+ await enable(extension)
+}
+
+async function load (extension: Extension) {
+ if (shouldLoad(extension)) {
+ logger.debug('load', extension.id)
+ const loadStatus: ExtensionLoadStatus = loaded.get(extension.id) || { themes: false, plugin: false, style: false, activationTime: 0 }
+
+ loadStatus.version = extension.version
+
+ let scriptStartTime = performance.now()
+ let scriptEndTime = scriptStartTime
+ let pluginPromise: Promise | undefined
+
+ const main = extension?.main
+ if (!loadStatus.plugin && main && (main.endsWith('.js') || main.endsWith('.mjs'))) {
+ pluginPromise = new Promise((resolve, reject) => {
+ const script = window.document.createElement('script')
+ script.src = getInstalledExtensionFileUrl(extension.id, main)
+ script.defer = true
+
+ // support esm
+ if (main.endsWith('.mjs')) {
+ script.type = 'module'
+ }
+
+ script.onload = () => {
+ resolve()
+ scriptEndTime = performance.now()
+ script.onload = null
+ }
+
+ script.onerror = (error) => {
+ reject(error)
+ scriptEndTime = performance.now()
+ script.onerror = null
+ }
+
+ window.document.body.appendChild(script)
+ setTimeout(() => {
+ scriptStartTime = performance.now()
+ }, 0)
+ })
+ }
+
+ const style = extension?.style
+ if (!loadStatus.style && style && style.endsWith('.css')) {
+ const href = getInstalledExtensionFileUrl(extension.id, style)
+
+ // add style to workbench
+ theme.addStyleLink(href)
+
+ // also add style to preview iframe
+ view.addStyleLink(href)
+
+ loadStatus.style = true
+ }
+
+ if (!loadStatus.themes && extension?.themes && extension.themes.length) {
+ extension.themes.forEach(style => {
+ theme.registerThemeStyle({
+ from: 'extension',
+ name: `[${extension.id}]: ${style.name}`,
+ css: `extension:${getExtensionPath(extension.id, style.css)}`,
+ })
+ })
+ loadStatus.themes = true
+ }
+
+ if (pluginPromise) {
+ try {
+ await pluginPromise
+ } catch (error) {
+ console.warn(`Load extension error [${extension.id}]`, error)
+ } finally {
+ loadStatus.plugin = true
+ loadStatus.activationTime = scriptEndTime - scriptStartTime
+ }
+ }
+
+ loaded.set(extension.id, loadStatus)
+ }
+}
+
+let initialized = false
+
+export function getInitialized () {
+ return initialized
+}
+
+export function whenInitialized (): Promise {
+ return new Promise(resolve => {
+ if (initialized) {
+ resolve()
+ } else {
+ registerHook('EXTENSION_READY', () => {
+ resolve()
+ }, true)
+ }
+ })
+}
+
+/**
+ * Initialization extension system
+ */
+export async function init () {
+ logger.debug('init')
+
+ const extensions = (await getInstalledExtensions()).filter(shouldLoad)
+
+ for (const extension of extensions) {
+ await load(extension)
+ }
+
+ initialized = true
+ triggerHook('EXTENSION_READY', { extensions })
+}
diff --git a/src/renderer/support/extensions.ts b/src/renderer/others/file-extensions.ts
similarity index 86%
rename from src/renderer/support/extensions.ts
rename to src/renderer/others/file-extensions.ts
index 03ea8dbf8..fa7c8a1af 100644
--- a/src/renderer/support/extensions.ts
+++ b/src/renderer/others/file-extensions.ts
@@ -48,6 +48,8 @@ const extensions = [
'.java',
'.jav',
'.js',
+ '.mjs',
+ '.cjs',
'.es6',
'.jsx',
'.kt',
@@ -112,6 +114,8 @@ const extensions = [
'.swift',
'.tcl',
'.ts',
+ '.mts',
+ '.cts',
'.tsx',
'.vb',
'.xml',
@@ -141,11 +145,19 @@ const extensions = [
'.azcli',
'.cls',
'.graphql',
- '.gql'
+ '.gql',
+ '.bib',
+ '.plantuml',
+ '.dot',
+ '.gv',
+ '.puml',
+ '.lrc',
]
const supported = (name: string) => {
- return extensions.includes(extname(name.toLowerCase()))
+ name = name.toLowerCase()
+ const ext = extname(name) || (name.startsWith('.') ? name : '')
+ return ext ? extensions.includes(ext) : false
}
export default {
diff --git a/src/renderer/others/find-in-preview.ts b/src/renderer/others/find-in-preview.ts
new file mode 100644
index 000000000..3ca594c5e
--- /dev/null
+++ b/src/renderer/others/find-in-preview.ts
@@ -0,0 +1,122 @@
+import { escapeRegExp } from 'lodash-es'
+
+interface Opts {
+ caseSensitive?: boolean;
+ regex?: boolean;
+}
+
+export interface IFindInPreview {
+ exec(pattern: string, opts: Opts): void;
+ getStats(): { count: number, current: number }
+ next(): boolean;
+ prev(): boolean;
+}
+
+export class BrowserFindInPreview implements IFindInPreview {
+ private _matchCount = 0
+ private _win: Window
+ private _maxMatchCount: number
+ private _maxMatchTime: number
+ private _wrapAround = false
+ private _matches: string[] = []
+ private _currentMatchIndex = 0
+ private _opts: Opts = {}
+ private _pattern = ''
+ private _exceed = false
+
+ constructor (win: Window, opts?: { maxMatchCount?: number, maxMatchTime?: number, wrapAround?: boolean }) {
+ this._win = win
+ this._maxMatchCount = opts?.maxMatchCount || 3000
+ this._maxMatchTime = opts?.maxMatchTime || 3000
+ this._wrapAround = !!opts?.wrapAround
+ }
+
+ exec (pattern: string, opts: Opts) {
+ this._opts = opts
+ this._pattern = pattern
+ this._matchCount = 0
+ this._currentMatchIndex = 0
+ this._matches = []
+ this._exceed = false
+
+ if (!pattern) {
+ return
+ }
+
+ const { caseSensitive, regex } = opts
+ const flags = caseSensitive ? 'g' : 'gi'
+ const re = regex ? new RegExp(pattern, flags) : new RegExp(escapeRegExp(pattern), flags)
+ // innerText will not return the text of hidden elements, and strip out tags while preserving newlines.
+ const content = this._win.document.body.innerText
+
+ const startTime = Date.now()
+ let match
+ while ((match = re.exec(content))) {
+ if (Date.now() - startTime > this._maxMatchTime) {
+ console.warn(`BrowserFindInContent: Reached maximum match time of ${this._maxMatchTime}ms.`)
+ this._exceed = true
+ break
+ }
+
+ if (this._matchCount >= this._maxMatchCount) {
+ console.warn(`BrowserFindInContent: Reached maximum match count of ${this._maxMatchCount}.`)
+ this._exceed = true
+ break
+ }
+
+ this._matchCount++
+ if (regex) {
+ this._matches.push(match[0])
+ }
+ }
+ }
+
+ getStats () {
+ return {
+ count: this._matchCount,
+ current: this._currentMatchIndex,
+ exceed: this._exceed,
+ }
+ }
+
+ next (): boolean {
+ return this._search(false)
+ }
+
+ prev (): boolean {
+ return this._search(true)
+ }
+
+ private _search (backward: boolean): boolean {
+ this._win.document.body.focus()
+ let pattern = this._pattern
+
+ let index = this._currentMatchIndex + (backward ? -1 : 1)
+ if (index < 0) {
+ index = 0
+ }
+
+ if (this._opts.regex) {
+ pattern = this._matches[index % this._matches.length]
+ }
+
+ console.log('BrowserFindInContent: Searching for pattern', pattern, 'index', index)
+
+ if (!pattern) {
+ return true
+ }
+
+ const found = (this._win as any).find(
+ pattern,
+ !!(this._opts.caseSensitive),
+ backward,
+ !!this._wrapAround
+ )
+
+ if (found || this._opts.regex) {
+ this._currentMatchIndex = index
+ }
+
+ return found
+ }
+}
diff --git a/src/renderer/others/fuzzy-match.ts b/src/renderer/others/fuzzy-match.ts
new file mode 100644
index 000000000..2d16a1f48
--- /dev/null
+++ b/src/renderer/others/fuzzy-match.ts
@@ -0,0 +1,195 @@
+// https://github.com/forrestthewoods/lib_fts/blob/master/code/fts_fuzzy_match.js
+
+// LICENSE
+//
+// This software is dual-licensed to the public domain and under the following
+// license: you are granted a perpetual, irrevocable license to copy, modify,
+// publish, and distribute this file as you see fit.
+//
+// VERSION
+// 0.1.0 (2016-03-28) Initial release
+//
+// AUTHOR
+// Forrest Smith
+//
+// CONTRIBUTORS
+// J�rgen Tjern� - async helper
+// Anurag Awasthi - updated to 0.2.0
+
+const SEQUENTIAL_BONUS = 15 // bonus for adjacent matches
+const SEPARATOR_BONUS = 30 // bonus if match occurs after a separator
+const CAMEL_BONUS = 30 // bonus if match is uppercase and prev is lower
+const FIRST_LETTER_BONUS = 15 // bonus if the first letter is matched
+
+const LEADING_LETTER_PENALTY = -5 // penalty applied for every letter in str before the first match
+const MAX_LEADING_LETTER_PENALTY = -15 // maximum penalty for leading letters
+const UNMATCHED_LETTER_PENALTY = -1
+
+/**
+ * Does a fuzzy search to find pattern inside a string.
+ * @param {*} pattern string pattern to search for
+ * @param {*} str string string which is being searched
+ * @returns [boolean, number] a boolean which tells if pattern was
+ * found or not and a search score
+ */
+export function fuzzyMatch (pattern: string, str: string) {
+ const recursionCount = 0
+ const recursionLimit = 10
+ const matches: never[] = []
+ const maxMatches = 256
+
+ const [matched, score] = fuzzyMatchRecursive(
+ pattern,
+ str,
+ 0 /* patternCurIndex */,
+ 0 /* strCurrIndex */,
+ null /* srcMatces */,
+ matches,
+ maxMatches,
+ 0 /* nextMatch */,
+ recursionCount,
+ recursionLimit
+ )
+
+ return { matched, score }
+}
+
+function fuzzyMatchRecursive (
+ pattern: string | any[],
+ str: string | any[],
+ patternCurIndex: number,
+ strCurrIndex: number,
+ srcMatces: null,
+ matches: any,
+ maxMatches: number,
+ nextMatch: number,
+ recursionCount: number,
+ recursionLimit: number
+): [boolean, number] {
+ let outScore = 0
+
+ // Return if recursion limit is reached.
+ if (++recursionCount >= recursionLimit) {
+ return [false, outScore]
+ }
+
+ // Return if we reached ends of strings.
+ if (patternCurIndex === pattern.length || strCurrIndex === str.length) {
+ return [false, outScore]
+ }
+
+ // Recursion params
+ let recursiveMatch = false
+ let bestRecursiveMatches: any[] = []
+ let bestRecursiveScore = 0
+
+ // Loop through pattern and str looking for a match.
+ let firstMatch = true
+ while (patternCurIndex < pattern.length && strCurrIndex < str.length) {
+ // Match found.
+ if (
+ pattern[patternCurIndex].toLowerCase() === str[strCurrIndex].toLowerCase()
+ ) {
+ if (nextMatch >= maxMatches) {
+ return [false, outScore]
+ }
+
+ if (firstMatch && srcMatces) {
+ matches = [...srcMatces]
+ firstMatch = false
+ }
+
+ const recursiveMatches: never[] = []
+ const [matched, recursiveScore] = fuzzyMatchRecursive(
+ pattern,
+ str,
+ patternCurIndex,
+ strCurrIndex + 1,
+ matches,
+ recursiveMatches,
+ maxMatches,
+ nextMatch,
+ recursionCount,
+ recursionLimit
+ )
+
+ if (matched) {
+ // Pick best recursive score.
+ if (!recursiveMatch || recursiveScore > bestRecursiveScore) {
+ bestRecursiveMatches = [...recursiveMatches]
+ bestRecursiveScore = recursiveScore
+ }
+ recursiveMatch = true
+ }
+
+ matches[nextMatch++] = strCurrIndex
+ ++patternCurIndex
+ }
+ ++strCurrIndex
+ }
+
+ const matched = patternCurIndex === pattern.length
+
+ if (matched) {
+ outScore = 100
+
+ // Apply leading letter penalty
+ let penalty = LEADING_LETTER_PENALTY * matches[0]
+ penalty =
+ penalty < MAX_LEADING_LETTER_PENALTY
+ ? MAX_LEADING_LETTER_PENALTY
+ : penalty
+ outScore += penalty
+
+ // Apply unmatched penalty
+ const unmatched = str.length - nextMatch
+ outScore += UNMATCHED_LETTER_PENALTY * unmatched
+
+ // Apply ordering bonuses
+ for (let i = 0; i < nextMatch; i++) {
+ const currIdx = matches[i]
+
+ if (i > 0) {
+ const prevIdx = matches[i - 1]
+ if (currIdx === prevIdx + 1) {
+ outScore += SEQUENTIAL_BONUS
+ }
+ }
+
+ // Check for bonuses based on neighbor character value.
+ if (currIdx > 0) {
+ // Camel case
+ const neighbor = str[currIdx - 1]
+ const curr = str[currIdx]
+ if (
+ neighbor !== neighbor.toUpperCase() &&
+ curr !== curr.toLowerCase()
+ ) {
+ outScore += CAMEL_BONUS
+ }
+ const isNeighbourSeparator = neighbor === '_' || neighbor === ' '
+ if (isNeighbourSeparator) {
+ outScore += SEPARATOR_BONUS
+ }
+ } else {
+ // First letter
+ outScore += FIRST_LETTER_BONUS
+ }
+ }
+
+ // Return best result
+ if (recursiveMatch && (!matched || bestRecursiveScore > outScore)) {
+ // Recursive score is better than "this"
+ matches = [...bestRecursiveMatches]
+ outScore = bestRecursiveScore
+ return [true, outScore]
+ } else if (matched) {
+ // "this" score is better than recursive
+ return [true, outScore]
+ } else {
+ return [false, outScore]
+ }
+ }
+
+ return [false, outScore]
+}
diff --git a/src/renderer/others/google-analytics.ts b/src/renderer/others/google-analytics.ts
new file mode 100644
index 000000000..208d2118d
--- /dev/null
+++ b/src/renderer/others/google-analytics.ts
@@ -0,0 +1,412 @@
+// https://gist.github.com/IjzerenHein/df3f65093038dd70ad871f926be6f45e/6b50659729b0acd8c80eabb30bc01df0d5a47d0a
+
+export type FirebaseAnalyticsJSCodedEvent = { [key: string]: any };
+
+export interface FirebaseAnalyticsJSConfig {
+ /**
+ * **(Required)** Measurement-Id as found in the web Firebase-config.
+ * The format is G-XXXXXXXXXX.
+ */
+ measurementId: string;
+}
+
+export interface FirebaseAnalyticsJSOptions {
+ /**
+ * **(Required)** Anonymously identifies a particular user, device, or browser instance.
+ * For the web, this is generally stored as a first-party cookie with a two-year expiration.
+ * For mobile apps, this is randomly generated for each particular instance of an application install.
+ * The value of this field should be a random UUID (version 4) as described in http://www.ietf.org/rfc/rfc4122.txt.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#cid
+ */
+ clientId: string;
+
+ /**
+ * Max cache time in msec (default = 5000).
+ * Caches events fired within a certain time-frame and then
+ * sends them to the Google Measurement API in a single batch.
+ */
+ maxCacheTime?: number;
+
+ /**
+ * Enables strict data format checks for logEvent and setUserProperties.
+ * When enabled, causes `logEvent` and `setUserProperties` to strictly check
+ * whether any event- names & values and user-properties conform to the
+ * native SDK requirements.
+ */
+ strictNativeEmulation?: boolean;
+
+ /**
+ * Document title (e.g. "My Awesome Page").
+ * This is a browser specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#dt
+ */
+ docTitle?: string;
+
+ /**
+ * Document location URL (e.g. "https://myawesomeapp.com").
+ * This is a browser specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#dl
+ */
+ docLocation?: string;
+
+ /**
+ * Screen-resolution in the format "WxH" (e.g "2000x1440").
+ * This is a browser specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#sr
+ */
+ screenRes?: string;
+
+ /**
+ * Application name (e.g. "My Awesome App").
+ * This is a mobile app specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#an
+ */
+ appName?: string;
+
+ /**
+ * Application version (e.g. "1.2").
+ * This is a mobile app specific field.
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#av
+ */
+ appVersion?: string;
+
+ /**
+ * User language (e.g. "en-us").
+ * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#ul
+ */
+ userLanguage?: string;
+
+ /**
+ * Origin (default = "firebase").
+ */
+ origin?: string;
+
+ /**
+ * Custom query arguments that are appended to the POST request that is send to the
+ * Google Measurement API v2.
+ *
+ * @example
+ * ```
+ * const analytics = new FirebaseAnalyticsJS(config, {
+ * appName: 'My Awesome App',
+ * customArg: {
+ * vp: '123x456', // Add viewport-size
+ * sd: '24-bits' // Add screen-colors
+ * }
+ * });
+ * ```
+ */
+ customArgs?: { [key: string]: any };
+}
+
+/**
+ * A pure JavaScript Google Firebase Analytics implementation that uses
+ * the HTTPS Measurement API 2 to send events to Google Analytics.
+ *
+ * This class provides an alternative for the Firebase Analytics module
+ * shipped with the Firebase JS SDK. That library uses the gtag.js dependency
+ * and requires certain browser features. This prevents the use
+ * analytics on other platforms, such as Node-js and react-native.
+ *
+ * FirebaseAnalyticsJS provides a bare-bone implementation of the new
+ * HTTPS Measurement API 2 protocol (which is undocumented), with an API
+ * that follows the Firebase Analytics JS SDK.
+ */
+export class FirebaseAnalyticsJS {
+ public readonly url: string
+ private enabled: boolean
+ public readonly config: FirebaseAnalyticsJSConfig
+ private userId?: string
+ private userProperties?: { [key: string]: any }
+ private screenName?: string
+ private eventQueue = new Set()
+ private options: FirebaseAnalyticsJSOptions
+ private flushEventsPromise: Promise = Promise.resolve()
+ private flushEventsTimer: any
+
+ constructor (config: FirebaseAnalyticsJSConfig, options: FirebaseAnalyticsJSOptions) {
+ // Verify the measurement- & client Ids
+ if (!config.measurementId) {
+ throw new Error(
+ 'No valid measurementId. Make sure to provide a valid measurementId with a G-XXXXXXXXXX format.'
+ )
+ }
+ if (!options.clientId) {
+ throw new Error(
+ 'No valid clientId. Make sure to provide a valid clientId with a UUID (v4) format.'
+ )
+ }
+
+ // Initialize
+ this.url = 'https://www.google-analytics.com/g/collect'
+ this.enabled = true
+ this.config = config
+ this.options = {
+ customArgs: {},
+ maxCacheTime: 5000,
+ strictNativeEmulation: false,
+ origin: 'firebase',
+ ...options,
+ }
+ }
+
+ /**
+ * Sends 1 or more coded-events to the back-end.
+ * When only 1 event is provided, it is send inside the query URL.
+ * When more than 1 event is provided, the event-data is send in
+ * the body of the POST request.
+ */
+ private async send (events: Set): Promise {
+ const { config, options } = this
+ let queryArgs: any = {
+ ...options.customArgs,
+ v: 2,
+ tid: config.measurementId,
+ cid: this.options.clientId,
+ }
+ if (options.userLanguage) queryArgs.ul = options.userLanguage
+ if (options.appName) queryArgs.an = options.appName
+ if (options.appVersion) queryArgs.av = options.appVersion
+ if (options.docTitle) queryArgs.dt = options.docTitle
+ if (options.docLocation) queryArgs.dl = options.docLocation
+ if (options.screenRes) queryArgs.sr = options.screenRes
+ let body = ''
+
+ if (events.size > 1) {
+ body = ''
+ events.forEach(event => {
+ body += encodeQueryArgs(event) + '\n'
+ })
+ } else if (events.size === 1) {
+ const event = events.values().next().value
+ queryArgs = {
+ ...event,
+ ...queryArgs,
+ }
+ }
+ const args = encodeQueryArgs(queryArgs)
+ await fetch(`${this.url}?${args}`, {
+ method: 'POST',
+ cache: 'no-cache',
+ body,
+ })
+ }
+
+ private async addEvent (event: FirebaseAnalyticsJSCodedEvent) {
+ const { userId, userProperties, screenName } = this
+
+ // Extend the event with the currently set User-id
+ if (userId) event.uid = userId
+ if (screenName) event['ep.screen_name'] = screenName
+
+ // Add user-properties
+ if (userProperties) {
+ for (const name in userProperties) {
+ event[name] = userProperties[name]
+ }
+
+ // Reset user-properties after the first event. This is what gtag.js seems
+ // to do as well, although I couldn't find any docs explaining this behavior.
+ this.userProperties = undefined
+ }
+
+ // Add the event to the queue
+ this.eventQueue.add(event)
+
+ // Start debounce timer
+ if (!this.flushEventsTimer) {
+ this.flushEventsTimer = setTimeout(async () => {
+ this.flushEventsTimer = undefined
+ try {
+ await this.flushEventsPromise
+ } catch (err) {
+ // nop
+ }
+ this.flushEventsPromise = this.flushEvents()
+ }, this.options.maxCacheTime)
+ }
+ }
+
+ private async flushEvents () {
+ if (!this.eventQueue.size) return
+ const events = new Set(this.eventQueue)
+ await this.send(events)
+ events.forEach(event => this.eventQueue.delete(event))
+ }
+
+ /**
+ * Clears any queued events and cancels the flush timer.
+ */
+ clearEvents () {
+ this.eventQueue.clear()
+ if (this.flushEventsTimer) {
+ clearTimeout(this.flushEventsTimer)
+ this.flushEventsTimer = 0
+ }
+ }
+
+ /**
+ * Parses an event (as passed to logEvent) and throws an error when the
+ * event-name or parameters are invalid.
+ *
+ * Upon success, returns the event in encoded format, ready to be send
+ * through the Google Measurement API v2.
+ */
+ static parseEvent (
+ options: FirebaseAnalyticsJSOptions,
+ eventName: string,
+ eventParams?: { [key: string]: any }
+ ): FirebaseAnalyticsJSCodedEvent {
+ if (
+ !eventName ||
+ !eventName.length ||
+ eventName.length > 40 ||
+ eventName[0] === '_' ||
+ !eventName.match(/^[A-Za-z_]+$/) ||
+ eventName.startsWith('firebase_') ||
+ eventName.startsWith('google_') ||
+ eventName.startsWith('ga_')
+ ) {
+ throw new Error(
+ 'Invalid event-name specified. Should contain 1 to 40 alphanumeric characters or underscores. The name must start with an alphabetic character.'
+ )
+ }
+ const params: FirebaseAnalyticsJSCodedEvent = {
+ en: eventName,
+ _et: Date.now(),
+ 'ep.origin': options.origin,
+ }
+ if (eventParams) {
+ for (const key in eventParams) {
+ const paramKey =
+ (SHORT_EVENT_PARAMS as any)[key] ||
+ (typeof eventParams[key] === 'number' ? `epn.${key}` : `ep.${key}`)
+ params[paramKey] = eventParams[key]
+ }
+ }
+ return params
+ }
+
+ /**
+ * Parses user-properties (as passed to setUserProperties) and throws an error when
+ * one of the user properties is invalid.
+ *
+ * Upon success, returns the user-properties in encoded format, ready to be send
+ * through the Google Measurement API v2.
+ */
+ static parseUserProperty (
+ options: FirebaseAnalyticsJSOptions,
+ userPropertyName: string,
+ userPropertyValue: any
+ ): string {
+ if (
+ !userPropertyName.length ||
+ userPropertyName.length > 24 ||
+ userPropertyName[0] === '_' ||
+ !userPropertyName.match(/^[A-Za-z_]+$/) ||
+ userPropertyName === 'user_id' ||
+ userPropertyName.startsWith('firebase_') ||
+ userPropertyName.startsWith('google_') ||
+ userPropertyName.startsWith('ga_')
+ ) {
+ throw new Error(
+ 'Invalid user-property name specified. Should contain 1 to 24 alphanumeric characters or underscores. The name must start with an alphabetic character.'
+ )
+ }
+ if (
+ userPropertyValue !== undefined &&
+ userPropertyValue !== null &&
+ options.strictNativeEmulation &&
+ (typeof userPropertyValue !== 'string' || userPropertyValue.length > 36)
+ ) {
+ throw new Error(
+ 'Invalid user-property value specified. Value should be a string of up to 36 characters long.'
+ )
+ }
+ return typeof userPropertyValue === 'number'
+ ? `upn.${userPropertyName}`
+ : `up.${userPropertyName}`
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#log-event
+ */
+ async logEvent (eventName: string, eventParams?: { [key: string]: any }): Promise {
+ const event = FirebaseAnalyticsJS.parseEvent(this.options, eventName, eventParams)
+ if (!this.enabled) return
+ return this.addEvent(event)
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-analytics-collection-enabled
+ */
+ async setAnalyticsCollectionEnabled (isEnabled: boolean): Promise {
+ this.enabled = isEnabled
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-current-screen
+ */
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ async setCurrentScreen (screenName?: string, screenClassOverride?: string): Promise {
+ if (screenName && screenName.length > 100) {
+ throw new Error(
+ 'Invalid screen-name specified. Should contain 1 to 100 characters. Set to undefined to clear the current screen name.'
+ )
+ }
+ if (!this.enabled) return
+ this.screenName = screenName || undefined
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-user-id
+ */
+ async setUserId (userId: string | null): Promise {
+ if (!this.enabled) return
+ this.userId = userId || undefined
+ }
+
+ /**
+ * https://firebase.google.com/docs/reference/js/firebase.analytics.Analytics#set-user-properties
+ */
+ async setUserProperties (userProperties: { [key: string]: any }): Promise {
+ if (!this.enabled) return
+ for (const name in userProperties) {
+ const val = userProperties[name]
+ const key = FirebaseAnalyticsJS.parseUserProperty(this.options, name, val)
+ if (val === null || val === undefined) {
+ if (this.userProperties) {
+ delete this.userProperties[key]
+ }
+ } else {
+ this.userProperties = this.userProperties || {}
+ this.userProperties[key] = val
+ }
+ }
+ }
+
+ /**
+ * Clears all analytics data for this instance.
+ */
+ async resetAnalyticsData () {
+ this.clearEvents()
+ this.screenName = undefined
+ this.userId = undefined
+ this.userProperties = undefined
+ }
+}
+
+function encodeQueryArgs (queryArgs: FirebaseAnalyticsJSCodedEvent): string {
+ const now = Date.now()
+ return Object.keys(queryArgs)
+ .map(key => {
+ return `${key}=${encodeURIComponent(
+ key === '_et' ? Math.max(now - queryArgs[key], 0) : queryArgs[key]
+ )}`
+ })
+ .join('&')
+}
+
+const SHORT_EVENT_PARAMS = {
+ currency: 'cu',
+}
diff --git a/src/renderer/others/indexer-worker.ts b/src/renderer/others/indexer-worker.ts
new file mode 100644
index 000000000..16433a638
--- /dev/null
+++ b/src/renderer/others/indexer-worker.ts
@@ -0,0 +1,343 @@
+import AsyncLock from 'async-lock'
+import MarkdownIt, { Token } from 'markdown-it'
+import { debounce, throttle } from 'lodash-es'
+import { JSONRPCClient, JSONRPCClientChannel, JSONRPCRequest, JSONRPCResponse, JSONRPCServer, JSONRPCServerChannel } from 'jsonrpc-bridge'
+import { fetchTree, readFile, watchFs } from '@fe/support/api'
+import { DOM_ATTR_NAME, FLAG_DEBUG, FLAG_DEMO, HELP_REPO_NAME, MODE } from '@fe/support/args'
+import * as utils from '@fe/utils/pure'
+import { DocumentEntity, documents } from '@fe/others/db'
+import type { Stats } from 'fs'
+import type { PathItem, Repo } from '@share/types'
+import type { IndexerHostExports } from '@fe/services/indexer'
+import type { Components, IndexItemLink, IndexItemResource } from '@fe/types'
+import { registerHook, removeHook, triggerHook } from '@fe/core/hook'
+import { isAnchorToken, isDataUrl, isResourceToken, parseLink } from '@fe/plugins/markdown-link/lib'
+
+const markdown = MarkdownIt({ linkify: false, breaks: true, html: true })
+
+markdown.core.ruler.at('inline', function (state) {
+ const tokens = state.tokens
+
+ for (let i = 0, l = tokens.length; i < l; i++) {
+ const tok = tokens[i]
+ if (tok.type === 'inline') {
+ state.md.inline.parse(tok.content, state.md, state.env, tok.children as any)
+
+ let map = tok.map
+
+ if (!map) {
+ // find previous token with map info
+ for (let j = i - 1; j >= 0; j--) {
+ if (tokens[j].map) {
+ map = tokens[j].map
+ break
+ }
+ }
+ }
+
+ for (let j = 0; j < tok.children!.length; j++) {
+ const token = tok.children![j]
+ ;(token as any)._block_map = map
+ }
+ }
+ }
+})
+
+const exportMain = {
+ triggerWatchRepo,
+ stopWatch,
+ importScripts: async (urlOrCode: string, isCode = false) => {
+ if (isCode) {
+ const url = URL.createObjectURL(new Blob([urlOrCode], { type: 'application/javascript' }))
+ await import(/* @vite-ignore */ url)
+ URL.revokeObjectURL(url)
+ } else {
+ await import(/* @vite-ignore */ urlOrCode)
+ }
+ },
+}
+
+class WorkerChannel implements JSONRPCServerChannel, JSONRPCClientChannel {
+ type: 'server' | 'client'
+
+ constructor (type: 'server' | 'client') {
+ this.type = type
+ }
+
+ send (message: JSONRPCRequest & JSONRPCResponse): void {
+ if (this.type === 'client' && 'method' in message) {
+ self.postMessage({ from: 'worker', message })
+ } else if (this.type === 'server' && 'result' in message) {
+ self.postMessage({ from: 'worker', message })
+ }
+ }
+
+ setMessageHandler (callback: (message: JSONRPCResponse & JSONRPCRequest) => void): void {
+ self.addEventListener('message', (event) => {
+ const { message, from } = event.data
+ if (from !== 'host') {
+ return
+ }
+
+ if (this.type === 'client' && 'result' in message) {
+ callback(message)
+ } else if (this.type === 'server' && 'method' in message) {
+ callback(message)
+ }
+ })
+ }
+}
+
+export type IndexerWorkerExports = { main: typeof exportMain }
+
+export interface IndexerWorkerCtx {
+ markdown: MarkdownIt;
+ bridgeClient: JSONRPCClient;
+ registerHook: typeof registerHook;
+ removeHook: typeof removeHook;
+ utils: typeof utils;
+}
+
+// provide main to host
+const bridgeServer = new JSONRPCServer(new WorkerChannel('server'), { debug: FLAG_DEBUG })
+bridgeServer.addModule('main', exportMain)
+
+// to call host
+const bridgeClient = new JSONRPCClient(new WorkerChannel('client'), { debug: FLAG_DEBUG })
+
+const processingStatus = {
+ total: 0,
+ indexed: 0,
+ ready: false,
+ startTime: 0,
+}
+
+function _reportStatus (repo: Repo, processing: string | null, cost: number) {
+ const { total, indexed, ready } = processingStatus
+ bridgeClient.call.ctx.indexer.updateIndexStatus(repo, { ready, total, indexed, processing, cost })
+}
+
+function _convertPathToPathItem (repo: Repo, payload: { path: string }): PathItem {
+ const relativePath = '/' + utils.path.relative(repo.path, payload.path)
+ return { repo: repo.name, path: relativePath }
+}
+
+const reportStatus = throttle(_reportStatus, 500, { leading: true, trailing: true })
+
+let repoFiles: Components.Tree.Node[] = [] // TODO cache
+let allMtimeMs: Map | null = null
+let toPutItems: (Omit & { id?: number })[] = []
+let reusedIds: number[] = []
+
+const triggerFsChangeHook = debounce((repo: Repo) => {
+ if (processingStatus.ready) {
+ bridgeClient.notify.ctx.triggerHook('INDEXER_FS_CHANGE', { repo })
+ }
+}, 500)
+
+class RepoWatcher {
+ logger = utils.getLogger('indexer-worker-repo-watcher')
+
+ lock = new AsyncLock()
+
+ // type Awaited = T extends PromiseLike ? Awaited : T;
+ handler: Awaited> | null = null
+
+ stopWatch () {
+ this.logger.debug('stopWatch', !!this.handler)
+ if (this.handler) {
+ this.handler.abort()
+ this.handler = null
+ }
+ }
+
+ private async _startWatch (repo: Repo) {
+ if (!repo.enableIndexing || repo.name === HELP_REPO_NAME || FLAG_DEMO || MODE !== 'normal') {
+ this.logger.debug('startWatch', 'skip', repo)
+ this.stopWatch()
+ return
+ }
+
+ this.logger.debug('startWatch', repo)
+
+ const ignored = ((await bridgeClient.call.ctx.setting.getSetting('tree.exclude')) || '') as string
+
+ processingStatus.total = 0
+ processingStatus.indexed = 0
+ processingStatus.ready = false
+ processingStatus.startTime = Date.now()
+
+ const include = '/$|.md$' // dir or md file
+
+ const initRes = await Promise.all([
+ fetchTree(repo.name, { by: 'mtime', order: 'desc' }, include, true).catch(() => []),
+ documents.findAllMtimeMsByRepo(repo.name),
+ ])
+
+ repoFiles = initRes[0]
+ allMtimeMs = initRes[1]
+ toPutItems = []
+ reusedIds = []
+
+ await triggerHook('WORKER_INDEXER_BEFORE_START_WATCH', { repo }, { breakable: true })
+
+ this.handler = await watchFs(
+ repo.name,
+ '/**/*',
+ { awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 50 }, alwaysStat: true, ignored, mdContent: true, mdFilesOnly: true },
+ async payload => {
+ this.logger.debug('startWatch onResult', payload.eventName, (payload as any).path)
+
+ if (processingStatus.ready && payload.eventName !== 'change' && payload.eventName !== 'ready') {
+ triggerFsChangeHook(repo)
+ }
+
+ if (payload.eventName === 'add' || payload.eventName === 'change') {
+ try {
+ if (!processingStatus.ready) {
+ processingStatus.total++
+ reportStatus(repo, payload.path, Date.now() - processingStatus.startTime)
+ }
+
+ await processMarkdownFile(repo, payload)
+ processingStatus.indexed++
+ } catch (error) {
+ this.logger.error('processFile error', error)
+ }
+ } else if (payload.eventName === 'ready') {
+ allMtimeMs = null
+ processingStatus.ready = true
+ const ids = toPutItems.length ? await documents.bulkPut(toPutItems) : []
+ await documents.deleteUnusedInRepo(repo.name, reusedIds.concat(ids))
+ toPutItems = []
+ reusedIds = []
+
+ reportStatus(repo, null, Date.now() - processingStatus.startTime)
+ } else if (payload.eventName === 'unlink') {
+ const doc = _convertPathToPathItem(repo, payload)
+ await documents.deletedByRepoAndPath(doc.repo, doc.path)
+ }
+ },
+ async error => {
+ this.logger.error('startWatch error', error)
+
+ // ignore system error
+ if ((error as any)?.syscall) {
+ return
+ }
+
+ // retry watch then other error occurred
+ await utils.sleep(2000)
+ this.triggerWatchRepo(repo)
+ }
+ )
+ }
+
+ async triggerWatchRepo (repo: Repo | null | undefined) {
+ this.lock.acquire('triggerWatch', async (done) => {
+ this.logger.debug('triggerWatch', repo)
+ this.stopWatch()
+ try {
+ if (repo?.name && repo?.path) {
+ await this._startWatch(repo)
+ }
+ } finally {
+ done()
+ }
+ })
+ }
+}
+
+const logger = utils.getLogger('indexer-worker')
+const watcher = new RepoWatcher()
+
+function triggerWatchRepo (repo: Repo | null | undefined) {
+ watcher.triggerWatchRepo(repo)
+}
+
+function stopWatch () {
+ watcher.stopWatch()
+}
+
+async function processMarkdownFile (repo: Repo, payload: { content?: string | null, path: string, stats?: Stats }): Promise {
+ const doc = _convertPathToPathItem(repo, payload)
+
+ const oldRecord = allMtimeMs ? allMtimeMs.get(doc.path) : await documents.findByRepoAndPath(doc.repo, doc.path)
+
+ if (oldRecord && oldRecord.mtimeMs === payload.stats?.mtimeMs) {
+ logger.debug('skip', oldRecord.id, doc.path)
+ reusedIds.push(oldRecord.id)
+ return
+ }
+
+ let content: string
+ if (typeof payload.content === 'string') {
+ content = payload.content
+ } else {
+ const res = await readFile(doc)
+ content = res.content
+ }
+
+ const env: Record = { file: doc }
+ const tokens = markdown.parse(content, env)
+
+ const links: IndexItemLink[] = []
+ const resources: IndexItemResource[] = []
+
+ const convert = (tokens: Token[]) => {
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i]
+ if (isAnchorToken(token)) {
+ const href = token.attrGet('href') || ''
+ const blockMap = (token as any)._block_map
+ if (!isDataUrl(href)) {
+ const isWikiLink = !!token.attrGet(DOM_ATTR_NAME.WIKI_LINK)
+ const parsedLink = isWikiLink ? parseLink(doc, href, true, repoFiles) : parseLink(doc, href, false)
+ if (parsedLink?.type === 'external') {
+ links.push({ href, internal: null, position: null, blockMap })
+ } else if (parsedLink?.type === 'internal') {
+ links.push({ href, internal: parsedLink.path, position: parsedLink.position, blockMap })
+ }
+ }
+ } else if (isResourceToken(token)) {
+ const path = token.attrGet(DOM_ATTR_NAME.TARGET_PATH)
+ const src = token.attrGet('src') || ''
+
+ if (!isDataUrl(src)) {
+ const blockMap = (token as any)._block_map
+ resources.push({ src, internal: path, tag: token.tag as any, blockMap })
+ }
+ }
+
+ if (token.children) {
+ convert(token.children)
+ }
+ }
+ }
+
+ convert(tokens)
+
+ const item = {
+ id: oldRecord?.id,
+ repo: doc.repo,
+ path: doc.path,
+ name: utils.path.basename(doc.path),
+ links,
+ resources,
+ frontmatter: env.attributes || {},
+ ctimeMs: payload.stats?.ctimeMs || 0,
+ mtimeMs: payload.stats?.mtimeMs || 0,
+ size: payload.stats?.size || 0,
+ }
+
+ if (processingStatus.ready) {
+ documents.put(item)
+ } else {
+ toPutItems.push(item)
+ }
+}
+
+// expose to plugin
+self.ctx = { bridgeClient, markdown, registerHook, removeHook, utils } satisfies IndexerWorkerCtx
+
+logger.debug('indexer-worker loaded', self.location.href)
diff --git a/src/renderer/others/monaco-indent-range-provider.js b/src/renderer/others/monaco-indent-range-provider.js
new file mode 100644
index 000000000..c7d62c9ac
--- /dev/null
+++ b/src/renderer/others/monaco-indent-range-provider.js
@@ -0,0 +1,181 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { FoldingRegions, MAX_LINE_NUMBER } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/foldingRanges.js';
+const MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT = 5000;
+export const ID_INDENT_PROVIDER = 'indent';
+export class IndentRangeProvider {
+ constructor(editorModel) {
+ this.editorModel = editorModel;
+ this.id = ID_INDENT_PROVIDER;
+ }
+ dispose() {
+ }
+ compute(cancelationToken) {
+ return Promise.resolve(computeRanges(this.editorModel, false, undefined));
+ }
+}
+
+const TextModel = {
+ computeIndentLevel(line, tabSize) {
+ let indent = 0;
+ let i = 0;
+ let len = line.length;
+ while (i < len) {
+ let chCode = line.charCodeAt(i);
+ if (chCode === 32 /* Space */) {
+ indent++;
+ }
+ else if (chCode === 9 /* Tab */) {
+ indent = indent - indent % tabSize + tabSize;
+ }
+ else {
+ break;
+ }
+ i++;
+ }
+ if (i === len) {
+ return -1; // line only consists of whitespace
+ }
+ return indent;
+ }
+}
+
+// public only for testing
+export class RangesCollector {
+ constructor(foldingRangesLimit) {
+ this._startIndexes = [];
+ this._endIndexes = [];
+ this._indentOccurrences = [];
+ this._length = 0;
+ this._foldingRangesLimit = foldingRangesLimit;
+ }
+ insertFirst(startLineNumber, endLineNumber, indent) {
+ if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {
+ return;
+ }
+ let index = this._length;
+ this._startIndexes[index] = startLineNumber;
+ this._endIndexes[index] = endLineNumber;
+ this._length++;
+ if (indent < 1000) {
+ this._indentOccurrences[indent] = (this._indentOccurrences[indent] || 0) + 1;
+ }
+ }
+ toIndentRanges(model) {
+ if (this._length <= this._foldingRangesLimit) {
+ // reverse and create arrays of the exact length
+ let startIndexes = new Uint32Array(this._length);
+ let endIndexes = new Uint32Array(this._length);
+ for (let i = this._length - 1, k = 0; i >= 0; i--, k++) {
+ startIndexes[k] = this._startIndexes[i];
+ endIndexes[k] = this._endIndexes[i];
+ }
+ return new FoldingRegions(startIndexes, endIndexes);
+ }
+ else {
+ let entries = 0;
+ let maxIndent = this._indentOccurrences.length;
+ for (let i = 0; i < this._indentOccurrences.length; i++) {
+ let n = this._indentOccurrences[i];
+ if (n) {
+ if (n + entries > this._foldingRangesLimit) {
+ maxIndent = i;
+ break;
+ }
+ entries += n;
+ }
+ }
+ const tabSize = model.getOptions().tabSize;
+ // reverse and create arrays of the exact length
+ let startIndexes = new Uint32Array(this._foldingRangesLimit);
+ let endIndexes = new Uint32Array(this._foldingRangesLimit);
+ for (let i = this._length - 1, k = 0; i >= 0; i--) {
+ let startIndex = this._startIndexes[i];
+ let lineContent = model.getLineContent(startIndex);
+ let indent = TextModel.computeIndentLevel(lineContent, tabSize);
+ if (indent < maxIndent || (indent === maxIndent && entries++ < this._foldingRangesLimit)) {
+ startIndexes[k] = startIndex;
+ endIndexes[k] = this._endIndexes[i];
+ k++;
+ }
+ }
+ return new FoldingRegions(startIndexes, endIndexes);
+ }
+ }
+}
+export function computeRanges(model, offSide, markers, foldingRangesLimit = MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT) {
+ const tabSize = model.getOptions().tabSize;
+ let result = new RangesCollector(foldingRangesLimit);
+ let pattern = undefined;
+ if (markers) {
+ pattern = new RegExp(`(${markers.start.source})|(?:${markers.end.source})`);
+ }
+ let previousRegions = [];
+ let line = model.getLineCount() + 1;
+ previousRegions.push({ indent: -1, endAbove: line, line }); // sentinel, to make sure there's at least one entry
+ for (let line = model.getLineCount(); line > 0; line--) {
+ let lineContent = model.getLineContent(line);
+ let indent = TextModel.computeIndentLevel(lineContent, tabSize);
+ let previous = previousRegions[previousRegions.length - 1];
+ if (indent === -1) {
+ if (offSide) {
+ // for offSide languages, empty lines are associated to the previous block
+ // note: the next block is already written to the results, so this only
+ // impacts the end position of the block before
+ previous.endAbove = line;
+ }
+ continue; // only whitespace
+ }
+ let m;
+ if (pattern && (m = lineContent.match(pattern))) {
+ // folding pattern match
+ if (m[1]) { // start pattern match
+ // discard all regions until the folding pattern
+ let i = previousRegions.length - 1;
+ while (i > 0 && previousRegions[i].indent !== -2) {
+ i--;
+ }
+ if (i > 0) {
+ previousRegions.length = i + 1;
+ previous = previousRegions[i];
+ // new folding range from pattern, includes the end line
+ result.insertFirst(line, previous.line, indent);
+ previous.line = line;
+ previous.indent = indent;
+ previous.endAbove = line;
+ continue;
+ }
+ else {
+ // no end marker found, treat line as a regular line
+ }
+ }
+ else { // end pattern match
+ previousRegions.push({ indent: -2, endAbove: line, line });
+ continue;
+ }
+ }
+ if (previous.indent > indent) {
+ // discard all regions with larger indent
+ do {
+ previousRegions.pop();
+ previous = previousRegions[previousRegions.length - 1];
+ } while (previous.indent > indent);
+ // new folding range
+ let endLineNumber = previous.endAbove - 1;
+ if (endLineNumber - line >= 1) { // needs at east size 1
+ result.insertFirst(line, endLineNumber, indent);
+ }
+ }
+ if (previous.indent === indent) {
+ previous.endAbove = line;
+ }
+ else { // previous.indent < indent
+ // new region with a bigger indent
+ previousRegions.push({ indent, endAbove: line, line });
+ }
+ }
+ return result.toIndentRanges(model);
+}
diff --git a/src/renderer/others/monaco-latex.ts b/src/renderer/others/monaco-latex.ts
new file mode 100644
index 000000000..509af299a
--- /dev/null
+++ b/src/renderer/others/monaco-latex.ts
@@ -0,0 +1,66 @@
+export default function (monacoEditor: any) {
+ monacoEditor.languages.register({ id: 'latex' })
+
+ monacoEditor.languages.setMonarchTokensProvider('latex', {
+ displayName: 'Latex',
+ name: 'latex',
+ mimeTypes: ['text/latex', 'text/tex'],
+ fileExtensions: ['tex', 'sty', 'cls'],
+
+ lineComment: '% ',
+
+ builtin: [
+ 'addcontentsline', 'addtocontents', 'addtocounter', 'address', 'addtolength', 'addvspace', 'alph', 'appendix',
+ 'arabic', 'author', 'backslash', 'baselineskip', 'baselinestretch', 'bf', 'bibitem', 'bigskipamount', 'bigskip',
+ 'boldmath', 'boldsymbol', 'cal', 'caption', 'cdots', 'centering', 'chapter', 'circle', 'cite', 'cleardoublepage',
+ 'clearpage', 'cline', 'closing', 'color', 'copyright', 'dashbox', 'date', 'ddots', 'documentclass', 'dotfill', 'em',
+ 'emph', 'ensuremath', 'epigraph', 'euro', 'fbox', 'flushbottom', 'fnsymbol', 'footnote', 'footnotemark',
+ 'footnotesize', 'footnotetext', 'frac', 'frame', 'framebox', 'frenchspacing', 'hfill', 'hline', 'href', 'hrulefill',
+ 'hspace', 'huge', 'Huge', 'hyphenation', 'include', 'includegraphics', 'includeonly', 'indent', 'input', 'it', 'item',
+ 'kill', 'label', 'large', 'Large', 'LARGE', 'LaTeX', 'LaTeXe', 'ldots', 'left', 'lefteqn', 'line', 'linebreak',
+ 'linethickness', 'linewidth', 'listoffigures', 'listoftables', 'location', 'makebox', 'maketitle', 'markboth',
+ 'mathcal', 'mathop', 'mbox', 'medskip', 'multicolumn', 'multiput', 'newcommand', 'newcolumntype', 'newcounter',
+ 'newenvironment', 'newfont', 'newlength', 'newline', 'newpage', 'newsavebox', 'newtheorem', 'nocite', 'noindent',
+ 'nolinebreak', 'nonfrenchspacing', 'normalsize', 'nopagebreak', 'not', 'onecolumn', 'opening', 'oval', 'overbrace',
+ 'overline', 'pagebreak', 'pagenumbering', 'pageref', 'pagestyle', 'par', 'paragraph', 'parbox', 'parindent', 'parskip',
+ 'part', 'protect', 'providecommand', 'put', 'raggedbottom', 'raggedleft', 'raggedright', 'raisebox', 'ref',
+ 'renewcommand', 'right', 'rm', 'roman', 'rule', 'savebox', 'sbox', 'sc', 'scriptsize', 'section', 'setcounter',
+ 'setlength', 'settowidth', 'sf', 'shortstack', 'signature', 'sl', 'slash', 'small', 'smallskip', 'sout', 'space', 'sqrt',
+ 'stackrel', 'stepcounter', 'subparagraph', 'subsection', 'subsubsection', 'tableofcontents', 'telephone', 'TeX',
+ 'textbf', 'textcolor', 'textit', 'textmd', 'textnormal', 'textrm', 'textsc', 'textsf', 'textsl', 'texttt', 'textup',
+ 'textwidth', 'textheight', 'thanks', 'thispagestyle', 'tiny', 'title', 'today', 'tt', 'twocolumn', 'typeout', 'typein',
+ 'uline', 'underbrace', 'underline', 'unitlength', 'usebox', 'usecounter', 'uwave', 'value', 'vbox', 'vcenter', 'vdots',
+ 'vector', 'verb', 'vfill', 'vline', 'vphantom', 'vspace',
+
+ 'RequirePackage', 'NeedsTeXFormat', 'usepackage', 'input', 'include', 'documentclass', 'documentstyle',
+ 'def', 'edef', 'defcommand', 'if', 'ifdim', 'ifnum', 'ifx', 'fi', 'else', 'begingroup', 'endgroup',
+ 'definecolor', 'textcolor', 'color',
+ 'eifstrequal', 'eeifstrequal'
+ ],
+
+ tokenizer: {
+ root: [
+ ['(\\\\begin)(\\s*)(\\{)([\\w\\-\\*\\@]+)(\\})',
+ ['keyword.predefined', 'white', '@brackets', { token: 'tag.env-$4', bracket: '@open' }, '@brackets']],
+ ['(\\\\end)(\\s*)(\\{)([\\w\\-\\*\\@]+)(\\})',
+ ['keyword.predefined', 'white', '@brackets', { token: 'tag.env-$4', bracket: '@close' }, '@brackets']],
+ ['\\\\[^a-zA-Z@]', 'keyword'],
+ ['\\@[a-zA-Z@]+', 'keyword.at'],
+ ['\\\\([a-zA-Z@]+)', {
+ cases: {
+ '$1@builtin': 'keyword.predefined',
+ '@default': 'keyword'
+ }
+ }],
+ { include: '@whitespace' },
+ ['[{}()\\[\\]]', '@brackets'],
+ ['#+\\d', 'number.arg'],
+ ['\\-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)\\s*(?:em|ex|pt|pc|sp|cm|mm|in)', 'number.len']
+ ],
+ whitespace: [
+ ['[ \\t\\r\\n]+', 'white'],
+ ['%.*$', 'comment']
+ ]
+ }
+ })
+}
diff --git a/src/renderer/others/premium.ts b/src/renderer/others/premium.ts
new file mode 100644
index 000000000..1c79217c6
--- /dev/null
+++ b/src/renderer/others/premium.ts
@@ -0,0 +1,294 @@
+import { LicenseToken } from 'app-license'
+import { PREMIUM_PUBLIC_KEY } from '@share/misc'
+import { getActionHandler } from '@fe/core/action'
+import * as api from '@fe/support/api'
+import { getSetting, setSetting } from '@fe/services/setting'
+import { refresh } from '@fe/services/view'
+import { FLAG_DEMO, FLAG_MAS, MODE } from '@fe/support/args'
+import ga from '@fe/support/ga'
+import { getLogger, md5 } from '@fe/utils'
+import { registerHook, triggerHook } from '@fe/core/hook'
+import { useToast } from '@fe/support/ui/toast'
+import type { PremiumTab } from '@fe/types'
+import { getCurrentLanguage } from '@fe/services/i18n'
+
+const tokenPrefix = 'ynkv2:'
+const logger = getLogger('premium')
+
+let lastPurchased: boolean | undefined
+let licenseToken: LicenseToken | null | undefined
+let upgradeTryCount = 0
+
+type Payload = {
+ fetchToken: { licenseId: string }
+ removeDevice: { licenseId: string, device: string }
+ addDevice: { licenseId: string }
+ fetchDevices: { licenseId: string }
+ upgradeLicense: { oldLicense: string, locale: string }
+ checkDevice: { device: string }
+ genDeviceString: {},
+}
+
+export async function requestApi (method: T, payload: Payload[T]) {
+ const { data } = await api.fetchHttp('/api/premium', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ method, payload }),
+ })
+
+ return data
+}
+
+async function fetchToken (licenseId: string) {
+ const token = await requestApi('fetchToken', { licenseId })
+ return new LicenseToken(token, { publicOrPrivateKey: PREMIUM_PUBLIC_KEY })
+}
+
+function syncCacheLicenseToken (token: LicenseToken | null) {
+ logger.debug('syncCacheLicenseToken', !!token)
+ const oldToken = licenseToken
+ licenseToken = token
+
+ if (oldToken?.status !== token?.status) {
+ refresh()
+ }
+
+ return licenseToken
+}
+
+export function tokenAvailableDays (token: LicenseToken) {
+ return Math.floor((token.expires.getTime() - Date.now()) / 1000 / 60 / 60 / 24)
+}
+
+export function tokenIsExpiredSoon (token: LicenseToken) {
+ if (FLAG_MAS) {
+ return false
+ }
+
+ const days = tokenAvailableDays(token)
+
+ return days <= 3 && days >= 0
+}
+
+export function tokenIsStaleSoon (token: LicenseToken) {
+ if (token.status === 'stale') {
+ return false
+ }
+
+ if (!token.fetchedAt.getTime()) {
+ return true
+ }
+
+ // if fetched at 25 days ago, it's stale soon
+ // if (token.fetchedAt.getTime() < Date.now() - 1000 * 60 * 60 * 24 * 25) {
+ // return true
+ // }
+
+ return false
+}
+
+async function upgradeV1License (oldLicense: string) {
+ logger.debug('upgradeV1License', oldLicense)
+ if (licenseToken) {
+ return
+ }
+
+ if (upgradeTryCount >= 1) {
+ return
+ }
+
+ upgradeTryCount++
+
+ try {
+ const licenseId = await requestApi('upgradeLicense', { oldLicense, locale: getCurrentLanguage() })
+ await activateLicense(licenseId)
+ useToast().show('info', 'License upgraded successfully')
+ showPremium('activation')
+ } catch (error) {
+ useToast().show('warning', `License upgrade failed, please contact support [${error}]`, 6000)
+ }
+}
+
+function _getPurchased (force = false) {
+ logger.debug('_getPurchased', force)
+ if (FLAG_DEMO || MODE === 'share-preview') {
+ return true
+ }
+
+ let token = licenseToken
+ if (typeof token === 'undefined' || force) {
+ token = getLicenseToken()
+ }
+
+ return !!(token?.isAvailable)
+}
+
+export function getPurchased (force = false) {
+ const val = _getPurchased(force)
+
+ if (typeof lastPurchased === 'boolean' && val !== lastPurchased) {
+ lastPurchased = val
+ triggerHook('PREMIUM_STATUS_CHANGED')
+ } else {
+ lastPurchased = val
+ }
+
+ return val
+}
+
+export function showPremium (tab?: PremiumTab) {
+ logger.debug('showPremium', tab)
+ upgradeTryCount = 0
+ getActionHandler('premium.show')(tab)
+ ga.logEvent('yn_premium_show', { purchased: getPurchased() })
+}
+
+export function getLicenseToken () {
+ logger.debug('getLicenseToken')
+ try {
+ const tokenStr = getSetting('license')
+ if (!tokenStr) {
+ return syncCacheLicenseToken(null)
+ }
+
+ if (!tokenStr.startsWith(tokenPrefix)) {
+ upgradeV1License(tokenStr)
+ return syncCacheLicenseToken(null)
+ }
+
+ const token = new LicenseToken(
+ tokenStr.slice(tokenPrefix.length),
+ { publicOrPrivateKey: PREMIUM_PUBLIC_KEY }
+ )
+
+ ga.setUserProperties({
+ expires: token.expires.toLocaleDateString(),
+ hash: md5(token.licenseId),
+ })
+
+ return syncCacheLicenseToken(token)
+ } catch (error) {
+ logger.error('getLicenseToken', error)
+ }
+
+ return syncCacheLicenseToken(null)
+}
+
+export async function cleanLicense () {
+ logger.debug('cleanLicense')
+ // do not clean old license
+ if (!getSetting('license', '').startsWith(tokenPrefix)) {
+ return
+ }
+
+ await setSetting('license', '')
+}
+
+async function setLicense (licenseId: string) {
+ logger.debug('setLicense', licenseId)
+ try {
+ if (!licenseId) {
+ return
+ }
+
+ try {
+ const token = await fetchToken(licenseId)
+
+ if (!token.isAvailable) {
+ throw new Error(`Error, license status [${token.status}]`)
+ }
+
+ await setSetting('license', tokenPrefix + token.toString())
+ } catch (error: any) {
+ if (error.message === 'DEVICE_NOT_FOUND' || error.message === 'INVALID_LICENSE') {
+ await cleanLicense()
+ }
+
+ throw error
+ }
+ } catch (error: any) {
+ logger.error('setLicense', error)
+ throw error
+ } finally {
+ getPurchased(true)
+ }
+}
+
+async function checkDevice (device: string) {
+ try {
+ await requestApi('checkDevice', { device })
+ } catch (error) {
+ cleanLicense()
+ throw error
+ }
+}
+
+export async function refreshLicense (opts?: { throwError?: boolean }) {
+ logger.debug('refreshLicense', opts)
+ try {
+ const token = getLicenseToken()
+ if (token) {
+ await checkDevice(token.device)
+ await setLicense(token.licenseId)
+ }
+ } catch (error) {
+ if (opts?.throwError) {
+ throw error
+ } else {
+ logger.error('refreshLicense', error)
+ }
+ }
+}
+
+export async function activateLicense (licenseId: string) {
+ logger.debug('activateLicense', licenseId)
+ await requestApi('addDevice', { licenseId })
+ await setLicense(licenseId)
+}
+
+export async function activateByTokenString (tokenString: string) {
+ logger.debug('activateByToken', tokenString)
+ await setSetting('license', tokenPrefix + tokenString)
+ const token = getLicenseToken()
+ if (token) {
+ await checkDevice(token.device)
+ } else {
+ throw new Error('INVALID_LICENSE')
+ }
+}
+
+function checkLicenseStatus () {
+ logger.debug('checkLicenseStatus')
+ const token = getLicenseToken()
+ if (token) {
+ if (token.status === 'stale') {
+ useToast().show('warning', 'License unrecognized, please refresh')
+ showPremium('activation')
+ } else if (token.status === 'expired') {
+ useToast().show('warning', 'License expired, please renew')
+ showPremium('activation')
+ } else if (tokenIsStaleSoon(token)) {
+ useToast().show('warning', 'License unrecognized, please refresh')
+ showPremium('activation')
+ } else if (tokenIsExpiredSoon(token)) {
+ useToast().show('warning', 'License expires soon, please renew')
+ showPremium('activation')
+ }
+ }
+}
+
+async function refreshAndCheckLicenseStatus () {
+ if (FLAG_DEMO || MODE === 'share-preview') {
+ return
+ }
+
+ logger.debug('refreshAndCheckLicenseStatus')
+ try {
+ await refreshLicense()
+ } finally {
+ checkLicenseStatus()
+ }
+}
+
+registerHook('STARTUP', refreshAndCheckLicenseStatus)
+setInterval(refreshAndCheckLicenseStatus, 1000 * 60 * 60 * 6) // 6 hours
diff --git a/src/renderer/others/prism-languages-all.ts b/src/renderer/others/prism-languages-all.ts
new file mode 100644
index 000000000..116048901
--- /dev/null
+++ b/src/renderer/others/prism-languages-all.ts
@@ -0,0 +1,297 @@
+import 'prismjs/components/prism-markup'
+import 'prismjs/components/prism-css'
+import 'prismjs/components/prism-clike'
+import 'prismjs/components/prism-regex'
+import 'prismjs/components/prism-javascript'
+import 'prismjs/components/prism-abap'
+import 'prismjs/components/prism-abnf'
+import 'prismjs/components/prism-actionscript'
+import 'prismjs/components/prism-ada'
+import 'prismjs/components/prism-agda'
+import 'prismjs/components/prism-al'
+import 'prismjs/components/prism-antlr4'
+import 'prismjs/components/prism-apacheconf'
+import 'prismjs/components/prism-sql'
+import 'prismjs/components/prism-apex'
+import 'prismjs/components/prism-apl'
+import 'prismjs/components/prism-applescript'
+import 'prismjs/components/prism-aql'
+import 'prismjs/components/prism-c'
+import 'prismjs/components/prism-cpp'
+import 'prismjs/components/prism-arduino'
+import 'prismjs/components/prism-arff'
+import 'prismjs/components/prism-armasm'
+import 'prismjs/components/prism-bash'
+import 'prismjs/components/prism-yaml'
+import 'prismjs/components/prism-markdown'
+import 'prismjs/components/prism-arturo'
+import 'prismjs/components/prism-asciidoc'
+import 'prismjs/components/prism-csharp'
+import 'prismjs/components/prism-aspnet'
+import 'prismjs/components/prism-asm6502'
+import 'prismjs/components/prism-asmatmel'
+import 'prismjs/components/prism-autohotkey'
+import 'prismjs/components/prism-autoit'
+import 'prismjs/components/prism-avisynth'
+import 'prismjs/components/prism-avro-idl'
+import 'prismjs/components/prism-awk'
+import 'prismjs/components/prism-basic'
+import 'prismjs/components/prism-batch'
+import 'prismjs/components/prism-bbcode'
+import 'prismjs/components/prism-bbj'
+import 'prismjs/components/prism-bicep'
+import 'prismjs/components/prism-birb'
+import 'prismjs/components/prism-bison'
+import 'prismjs/components/prism-bnf'
+import 'prismjs/components/prism-bqn'
+import 'prismjs/components/prism-brainfuck'
+import 'prismjs/components/prism-brightscript'
+import 'prismjs/components/prism-bro'
+import 'prismjs/components/prism-bsl'
+import 'prismjs/components/prism-cfscript'
+import 'prismjs/components/prism-chaiscript'
+import 'prismjs/components/prism-cil'
+import 'prismjs/components/prism-cilkc'
+import 'prismjs/components/prism-cilkcpp'
+import 'prismjs/components/prism-clojure'
+import 'prismjs/components/prism-cmake'
+import 'prismjs/components/prism-cobol'
+import 'prismjs/components/prism-coffeescript'
+import 'prismjs/components/prism-concurnas'
+import 'prismjs/components/prism-csp'
+import 'prismjs/components/prism-cooklang'
+import 'prismjs/components/prism-coq'
+import 'prismjs/components/prism-ruby'
+import 'prismjs/components/prism-crystal'
+import 'prismjs/components/prism-css-extras'
+import 'prismjs/components/prism-csv'
+import 'prismjs/components/prism-cue'
+import 'prismjs/components/prism-cypher'
+import 'prismjs/components/prism-d'
+import 'prismjs/components/prism-dart'
+import 'prismjs/components/prism-dataweave'
+import 'prismjs/components/prism-dax'
+import 'prismjs/components/prism-dhall'
+import 'prismjs/components/prism-diff'
+import 'prismjs/components/prism-markup-templating'
+import 'prismjs/components/prism-django'
+import 'prismjs/components/prism-dns-zone-file'
+import 'prismjs/components/prism-docker'
+import 'prismjs/components/prism-dot'
+import 'prismjs/components/prism-ebnf'
+import 'prismjs/components/prism-editorconfig'
+import 'prismjs/components/prism-eiffel'
+import 'prismjs/components/prism-ejs'
+import 'prismjs/components/prism-elixir'
+import 'prismjs/components/prism-elm'
+import 'prismjs/components/prism-lua'
+import 'prismjs/components/prism-etlua'
+import 'prismjs/components/prism-erb'
+import 'prismjs/components/prism-erlang'
+import 'prismjs/components/prism-excel-formula'
+import 'prismjs/components/prism-fsharp'
+import 'prismjs/components/prism-factor'
+import 'prismjs/components/prism-false'
+import 'prismjs/components/prism-firestore-security-rules'
+import 'prismjs/components/prism-flow'
+import 'prismjs/components/prism-fortran'
+import 'prismjs/components/prism-ftl'
+import 'prismjs/components/prism-gml'
+import 'prismjs/components/prism-gap'
+import 'prismjs/components/prism-gcode'
+import 'prismjs/components/prism-gdscript'
+import 'prismjs/components/prism-gedcom'
+import 'prismjs/components/prism-gettext'
+import 'prismjs/components/prism-gherkin'
+import 'prismjs/components/prism-git'
+import 'prismjs/components/prism-glsl'
+import 'prismjs/components/prism-gn'
+import 'prismjs/components/prism-linker-script'
+import 'prismjs/components/prism-go'
+import 'prismjs/components/prism-go-module'
+import 'prismjs/components/prism-gradle'
+import 'prismjs/components/prism-graphql'
+import 'prismjs/components/prism-groovy'
+import 'prismjs/components/prism-less'
+import 'prismjs/components/prism-scss'
+import 'prismjs/components/prism-textile'
+import 'prismjs/components/prism-haml'
+import 'prismjs/components/prism-handlebars'
+import 'prismjs/components/prism-haskell'
+import 'prismjs/components/prism-haxe'
+import 'prismjs/components/prism-hcl'
+import 'prismjs/components/prism-hlsl'
+import 'prismjs/components/prism-hoon'
+import 'prismjs/components/prism-hpkp'
+import 'prismjs/components/prism-hsts'
+import 'prismjs/components/prism-json'
+import 'prismjs/components/prism-uri'
+import 'prismjs/components/prism-http'
+import 'prismjs/components/prism-ichigojam'
+import 'prismjs/components/prism-icon'
+import 'prismjs/components/prism-icu-message-format'
+import 'prismjs/components/prism-idris'
+import 'prismjs/components/prism-ignore'
+import 'prismjs/components/prism-inform7'
+import 'prismjs/components/prism-ini'
+import 'prismjs/components/prism-io'
+import 'prismjs/components/prism-j'
+import 'prismjs/components/prism-java'
+import 'prismjs/components/prism-php'
+import 'prismjs/components/prism-javadoclike'
+import 'prismjs/components/prism-scala'
+import 'prismjs/components/prism-javadoc'
+import 'prismjs/components/prism-javastacktrace'
+import 'prismjs/components/prism-jexl'
+import 'prismjs/components/prism-jolie'
+import 'prismjs/components/prism-jq'
+import 'prismjs/components/prism-js-templates'
+import 'prismjs/components/prism-typescript'
+import 'prismjs/components/prism-jsdoc'
+import 'prismjs/components/prism-n4js'
+import 'prismjs/components/prism-js-extras'
+import 'prismjs/components/prism-json5'
+import 'prismjs/components/prism-jsonp'
+import 'prismjs/components/prism-jsstacktrace'
+import 'prismjs/components/prism-julia'
+import 'prismjs/components/prism-keepalived'
+import 'prismjs/components/prism-keyman'
+import 'prismjs/components/prism-kotlin'
+import 'prismjs/components/prism-kumir'
+import 'prismjs/components/prism-kusto'
+import 'prismjs/components/prism-latex'
+import 'prismjs/components/prism-latte'
+import 'prismjs/components/prism-scheme'
+import 'prismjs/components/prism-lilypond'
+import 'prismjs/components/prism-liquid'
+import 'prismjs/components/prism-lisp'
+import 'prismjs/components/prism-livescript'
+import 'prismjs/components/prism-llvm'
+import 'prismjs/components/prism-log'
+import 'prismjs/components/prism-lolcode'
+import 'prismjs/components/prism-magma'
+import 'prismjs/components/prism-makefile'
+import 'prismjs/components/prism-mata'
+import 'prismjs/components/prism-matlab'
+import 'prismjs/components/prism-maxscript'
+import 'prismjs/components/prism-mel'
+import 'prismjs/components/prism-mermaid'
+import 'prismjs/components/prism-metafont'
+import 'prismjs/components/prism-mizar'
+import 'prismjs/components/prism-mongodb'
+import 'prismjs/components/prism-monkey'
+import 'prismjs/components/prism-moonscript'
+import 'prismjs/components/prism-n1ql'
+import 'prismjs/components/prism-nand2tetris-hdl'
+import 'prismjs/components/prism-naniscript'
+import 'prismjs/components/prism-nasm'
+import 'prismjs/components/prism-neon'
+import 'prismjs/components/prism-nevod'
+import 'prismjs/components/prism-nginx'
+import 'prismjs/components/prism-nim'
+import 'prismjs/components/prism-nix'
+import 'prismjs/components/prism-nsis'
+import 'prismjs/components/prism-objectivec'
+import 'prismjs/components/prism-ocaml'
+import 'prismjs/components/prism-odin'
+import 'prismjs/components/prism-opencl'
+import 'prismjs/components/prism-openqasm'
+import 'prismjs/components/prism-oz'
+import 'prismjs/components/prism-parigp'
+import 'prismjs/components/prism-parser'
+import 'prismjs/components/prism-pascal'
+import 'prismjs/components/prism-pascaligo'
+import 'prismjs/components/prism-psl'
+import 'prismjs/components/prism-pcaxis'
+import 'prismjs/components/prism-peoplecode'
+import 'prismjs/components/prism-perl'
+import 'prismjs/components/prism-phpdoc'
+import 'prismjs/components/prism-php-extras'
+import 'prismjs/components/prism-plant-uml'
+import 'prismjs/components/prism-plsql'
+import 'prismjs/components/prism-powerquery'
+import 'prismjs/components/prism-powershell'
+import 'prismjs/components/prism-processing'
+import 'prismjs/components/prism-prolog'
+import 'prismjs/components/prism-promql'
+import 'prismjs/components/prism-properties'
+import 'prismjs/components/prism-protobuf'
+import 'prismjs/components/prism-stylus'
+import 'prismjs/components/prism-twig'
+import 'prismjs/components/prism-pug'
+import 'prismjs/components/prism-puppet'
+import 'prismjs/components/prism-pure'
+import 'prismjs/components/prism-purebasic'
+import 'prismjs/components/prism-purescript'
+import 'prismjs/components/prism-python'
+import 'prismjs/components/prism-qsharp'
+import 'prismjs/components/prism-q'
+import 'prismjs/components/prism-qml'
+import 'prismjs/components/prism-qore'
+import 'prismjs/components/prism-r'
+import 'prismjs/components/prism-racket'
+import 'prismjs/components/prism-cshtml'
+import 'prismjs/components/prism-jsx'
+import 'prismjs/components/prism-tsx'
+import 'prismjs/components/prism-reason'
+import 'prismjs/components/prism-rego'
+import 'prismjs/components/prism-renpy'
+import 'prismjs/components/prism-rescript'
+import 'prismjs/components/prism-rest'
+import 'prismjs/components/prism-rip'
+import 'prismjs/components/prism-roboconf'
+import 'prismjs/components/prism-robotframework'
+import 'prismjs/components/prism-rust'
+import 'prismjs/components/prism-sas'
+import 'prismjs/components/prism-sass'
+import 'prismjs/components/prism-shell-session'
+import 'prismjs/components/prism-smali'
+import 'prismjs/components/prism-smalltalk'
+import 'prismjs/components/prism-smarty'
+import 'prismjs/components/prism-sml'
+import 'prismjs/components/prism-solidity'
+import 'prismjs/components/prism-solution-file'
+import 'prismjs/components/prism-soy'
+import 'prismjs/components/prism-turtle'
+import 'prismjs/components/prism-sparql'
+import 'prismjs/components/prism-splunk-spl'
+import 'prismjs/components/prism-sqf'
+import 'prismjs/components/prism-squirrel'
+import 'prismjs/components/prism-stan'
+import 'prismjs/components/prism-stata'
+import 'prismjs/components/prism-iecst'
+import 'prismjs/components/prism-supercollider'
+import 'prismjs/components/prism-swift'
+import 'prismjs/components/prism-systemd'
+import 'prismjs/components/prism-t4-templating'
+import 'prismjs/components/prism-t4-cs'
+import 'prismjs/components/prism-vbnet'
+import 'prismjs/components/prism-t4-vb'
+import 'prismjs/components/prism-tap'
+import 'prismjs/components/prism-tcl'
+import 'prismjs/components/prism-tt2'
+import 'prismjs/components/prism-toml'
+import 'prismjs/components/prism-tremor'
+import 'prismjs/components/prism-typoscript'
+import 'prismjs/components/prism-unrealscript'
+import 'prismjs/components/prism-uorazor'
+import 'prismjs/components/prism-v'
+import 'prismjs/components/prism-vala'
+import 'prismjs/components/prism-velocity'
+import 'prismjs/components/prism-verilog'
+import 'prismjs/components/prism-vhdl'
+import 'prismjs/components/prism-vim'
+import 'prismjs/components/prism-visual-basic'
+import 'prismjs/components/prism-warpscript'
+import 'prismjs/components/prism-wasm'
+import 'prismjs/components/prism-web-idl'
+import 'prismjs/components/prism-wgsl'
+import 'prismjs/components/prism-wiki'
+import 'prismjs/components/prism-wolfram'
+import 'prismjs/components/prism-wren'
+import 'prismjs/components/prism-xeora'
+import 'prismjs/components/prism-xml-doc'
+import 'prismjs/components/prism-xojo'
+import 'prismjs/components/prism-xquery'
+import 'prismjs/components/prism-yang'
+import 'prismjs/components/prism-zig'
diff --git a/src/renderer/others/prism-style.scss b/src/renderer/others/prism-style.scss
new file mode 100644
index 000000000..7e911d497
--- /dev/null
+++ b/src/renderer/others/prism-style.scss
@@ -0,0 +1,25 @@
+@use 'sass:meta';
+@use '@fe/styles/mixins.scss' as *;
+@import 'prismjs/themes/prism.css';
+
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+ background: none;
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+ text-shadow: none;
+ background: var(--selection-color);
+}
+
+@include dark-theme {
+ code[class*="language-"], pre[class*="language-"] {
+ text-shadow: none;
+ }
+
+ @include meta.load-css('prismjs/themes/prism-tomorrow');
+}
diff --git a/src/renderer/others/semver.js b/src/renderer/others/semver.js
new file mode 100644
index 000000000..5a2980036
--- /dev/null
+++ b/src/renderer/others/semver.js
@@ -0,0 +1,2373 @@
+/**
+ * node-semver https://github.com/npm/node-semve
+ * this file generate by vite
+ * fix semver not work using vite
+ */
+
+ var __create = Object.create;
+ var __defProp = Object.defineProperty;
+ var __defProps = Object.defineProperties;
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+ var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+ var __getOwnPropNames = Object.getOwnPropertyNames;
+ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+ var __getProtoOf = Object.getPrototypeOf;
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
+ var __propIsEnum = Object.prototype.propertyIsEnumerable;
+ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+ var __spreadValues = (a, b) => {
+ for (var prop in b || (b = {}))
+ if (__hasOwnProp.call(b, prop))
+ __defNormalProp(a, prop, b[prop]);
+ if (__getOwnPropSymbols)
+ for (var prop of __getOwnPropSymbols(b)) {
+ if (__propIsEnum.call(b, prop))
+ __defNormalProp(a, prop, b[prop]);
+ }
+ return a;
+ };
+ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+ get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+ }) : x)(function(x) {
+ if (typeof require !== "undefined")
+ return require.apply(this, arguments);
+ throw new Error('Dynamic require of "' + x + '" is not supported');
+ });
+ var __esm = (fn, res) => function __init() {
+ return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+ };
+ var __commonJS = (cb, mod) => function __require2() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+ };
+ var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+ };
+ var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+ };
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+ // node_modules/semver/internal/constants.js
+ var require_constants = __commonJS({
+ "node_modules/semver/internal/constants.js"(exports, module) {
+ var SEMVER_SPEC_VERSION = "2.0.0";
+ var MAX_LENGTH = 256;
+ var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+ var MAX_SAFE_COMPONENT_LENGTH = 16;
+ module.exports = {
+ SEMVER_SPEC_VERSION,
+ MAX_LENGTH,
+ MAX_SAFE_INTEGER,
+ MAX_SAFE_COMPONENT_LENGTH
+ };
+ }
+ });
+
+ // node_modules/semver/internal/debug.js
+ var require_debug = __commonJS({
+ "node_modules/semver/internal/debug.js"(exports, module) {
+ var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+ };
+ module.exports = debug;
+ }
+ });
+
+ // node_modules/semver/internal/re.js
+ var require_re = __commonJS({
+ "node_modules/semver/internal/re.js"(exports, module) {
+ var { MAX_SAFE_COMPONENT_LENGTH } = require_constants();
+ var debug = require_debug();
+ exports = module.exports = {};
+ var re = exports.re = [];
+ var src = exports.src = [];
+ var t = exports.t = {};
+ var R = 0;
+ var createToken = (name, value, isGlobal) => {
+ const index = R++;
+ debug(name, index, value);
+ t[name] = index;
+ src[index] = value;
+ re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+ };
+ createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+ createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+");
+ createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*");
+ createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+ createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+ createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+ createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+ createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+");
+ createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+ createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+ createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+ createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+ createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+ createToken("GTLT", "((?:<|>)?=?)");
+ createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+ createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+ createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+ createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+ createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+ createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`);
+ createToken("COERCERTL", src[t.COERCE], true);
+ createToken("LONETILDE", "(?:~>?)");
+ createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+ exports.tildeTrimReplace = "$1~";
+ createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+ createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("LONECARET", "(?:\\^)");
+ createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+ exports.caretTrimReplace = "$1^";
+ createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+ createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+ createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+ createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+ exports.comparatorTrimReplace = "$1$2$3";
+ createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+ createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+ createToken("STAR", "(<|>)?=?\\s*\\*");
+ createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+ createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+ }
+ });
+
+ // node_modules/semver/internal/parse-options.js
+ var require_parse_options = __commonJS({
+ "node_modules/semver/internal/parse-options.js"(exports, module) {
+ var opts = ["includePrerelease", "loose", "rtl"];
+ var parseOptions = (options) => !options ? {} : typeof options !== "object" ? { loose: true } : opts.filter((k) => options[k]).reduce((o, k) => {
+ o[k] = true;
+ return o;
+ }, {});
+ module.exports = parseOptions;
+ }
+ });
+
+ // node_modules/semver/internal/identifiers.js
+ var require_identifiers = __commonJS({
+ "node_modules/semver/internal/identifiers.js"(exports, module) {
+ var numeric = /^[0-9]+$/;
+ var compareIdentifiers = (a, b) => {
+ const anum = numeric.test(a);
+ const bnum = numeric.test(b);
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+ return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+ };
+ var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+ module.exports = {
+ compareIdentifiers,
+ rcompareIdentifiers
+ };
+ }
+ });
+
+ // node_modules/semver/classes/semver.js
+ var require_semver = __commonJS({
+ "node_modules/semver/classes/semver.js"(exports, module) {
+ var debug = require_debug();
+ var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+ var { re, t } = require_re();
+ var parseOptions = require_parse_options();
+ var { compareIdentifiers } = require_identifiers();
+ var SemVer = class {
+ constructor(version, options) {
+ options = parseOptions(options);
+ if (version instanceof SemVer) {
+ if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+ return version;
+ } else {
+ version = version.version;
+ }
+ } else if (typeof version !== "string") {
+ throw new TypeError(`Invalid Version: ${version}`);
+ }
+ if (version.length > MAX_LENGTH) {
+ throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+ }
+ debug("SemVer", version, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+ const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+ if (!m) {
+ throw new TypeError(`Invalid Version: ${version}`);
+ }
+ this.raw = version;
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+ throw new TypeError("Invalid major version");
+ }
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+ throw new TypeError("Invalid minor version");
+ }
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+ throw new TypeError("Invalid patch version");
+ }
+ if (!m[4]) {
+ this.prerelease = [];
+ } else {
+ this.prerelease = m[4].split(".").map((id) => {
+ if (/^[0-9]+$/.test(id)) {
+ const num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER) {
+ return num;
+ }
+ }
+ return id;
+ });
+ }
+ this.build = m[5] ? m[5].split(".") : [];
+ this.format();
+ }
+ format() {
+ this.version = `${this.major}.${this.minor}.${this.patch}`;
+ if (this.prerelease.length) {
+ this.version += `-${this.prerelease.join(".")}`;
+ }
+ return this.version;
+ }
+ toString() {
+ return this.version;
+ }
+ compare(other) {
+ debug("SemVer.compare", this.version, this.options, other);
+ if (!(other instanceof SemVer)) {
+ if (typeof other === "string" && other === this.version) {
+ return 0;
+ }
+ other = new SemVer(other, this.options);
+ }
+ if (other.version === this.version) {
+ return 0;
+ }
+ return this.compareMain(other) || this.comparePre(other);
+ }
+ compareMain(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+ }
+ comparePre(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ if (this.prerelease.length && !other.prerelease.length) {
+ return -1;
+ } else if (!this.prerelease.length && other.prerelease.length) {
+ return 1;
+ } else if (!this.prerelease.length && !other.prerelease.length) {
+ return 0;
+ }
+ let i = 0;
+ do {
+ const a = this.prerelease[i];
+ const b = other.prerelease[i];
+ debug("prerelease compare", i, a, b);
+ if (a === void 0 && b === void 0) {
+ return 0;
+ } else if (b === void 0) {
+ return 1;
+ } else if (a === void 0) {
+ return -1;
+ } else if (a === b) {
+ continue;
+ } else {
+ return compareIdentifiers(a, b);
+ }
+ } while (++i);
+ }
+ compareBuild(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ let i = 0;
+ do {
+ const a = this.build[i];
+ const b = other.build[i];
+ debug("prerelease compare", i, a, b);
+ if (a === void 0 && b === void 0) {
+ return 0;
+ } else if (b === void 0) {
+ return 1;
+ } else if (a === void 0) {
+ return -1;
+ } else if (a === b) {
+ continue;
+ } else {
+ return compareIdentifiers(a, b);
+ }
+ } while (++i);
+ }
+ inc(release, identifier) {
+ switch (release) {
+ case "premajor":
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc("pre", identifier);
+ break;
+ case "preminor":
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc("pre", identifier);
+ break;
+ case "prepatch":
+ this.prerelease.length = 0;
+ this.inc("patch", identifier);
+ this.inc("pre", identifier);
+ break;
+ case "prerelease":
+ if (this.prerelease.length === 0) {
+ this.inc("patch", identifier);
+ }
+ this.inc("pre", identifier);
+ break;
+ case "major":
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+ this.major++;
+ }
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case "minor":
+ if (this.patch !== 0 || this.prerelease.length === 0) {
+ this.minor++;
+ }
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case "patch":
+ if (this.prerelease.length === 0) {
+ this.patch++;
+ }
+ this.prerelease = [];
+ break;
+ case "pre":
+ if (this.prerelease.length === 0) {
+ this.prerelease = [0];
+ } else {
+ let i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === "number") {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) {
+ this.prerelease.push(0);
+ }
+ }
+ if (identifier) {
+ if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+ if (isNaN(this.prerelease[1])) {
+ this.prerelease = [identifier, 0];
+ }
+ } else {
+ this.prerelease = [identifier, 0];
+ }
+ }
+ break;
+ default:
+ throw new Error(`invalid increment argument: ${release}`);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+ }
+ };
+ module.exports = SemVer;
+ }
+ });
+
+ // node_modules/semver/functions/parse.js
+ var require_parse = __commonJS({
+ "node_modules/semver/functions/parse.js"(exports, module) {
+ var { MAX_LENGTH } = require_constants();
+ var { re, t } = require_re();
+ var SemVer = require_semver();
+ var parseOptions = require_parse_options();
+ var parse = (version, options) => {
+ options = parseOptions(options);
+ if (version instanceof SemVer) {
+ return version;
+ }
+ if (typeof version !== "string") {
+ return null;
+ }
+ if (version.length > MAX_LENGTH) {
+ return null;
+ }
+ const r = options.loose ? re[t.LOOSE] : re[t.FULL];
+ if (!r.test(version)) {
+ return null;
+ }
+ try {
+ return new SemVer(version, options);
+ } catch (er) {
+ return null;
+ }
+ };
+ module.exports = parse;
+ }
+ });
+
+ // node_modules/semver/functions/valid.js
+ var require_valid = __commonJS({
+ "node_modules/semver/functions/valid.js"(exports, module) {
+ var parse = require_parse();
+ var valid = (version, options) => {
+ const v = parse(version, options);
+ return v ? v.version : null;
+ };
+ module.exports = valid;
+ }
+ });
+
+ // node_modules/semver/functions/clean.js
+ var require_clean = __commonJS({
+ "node_modules/semver/functions/clean.js"(exports, module) {
+ var parse = require_parse();
+ var clean = (version, options) => {
+ const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+ return s ? s.version : null;
+ };
+ module.exports = clean;
+ }
+ });
+
+ // node_modules/semver/functions/inc.js
+ var require_inc = __commonJS({
+ "node_modules/semver/functions/inc.js"(exports, module) {
+ var SemVer = require_semver();
+ var inc = (version, release, options, identifier) => {
+ if (typeof options === "string") {
+ identifier = options;
+ options = void 0;
+ }
+ try {
+ return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+ };
+ module.exports = inc;
+ }
+ });
+
+ // node_modules/semver/functions/compare.js
+ var require_compare = __commonJS({
+ "node_modules/semver/functions/compare.js"(exports, module) {
+ var SemVer = require_semver();
+ var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+ module.exports = compare;
+ }
+ });
+
+ // node_modules/semver/functions/eq.js
+ var require_eq = __commonJS({
+ "node_modules/semver/functions/eq.js"(exports, module) {
+ var compare = require_compare();
+ var eq = (a, b, loose) => compare(a, b, loose) === 0;
+ module.exports = eq;
+ }
+ });
+
+ // node_modules/semver/functions/diff.js
+ var require_diff = __commonJS({
+ "node_modules/semver/functions/diff.js"(exports, module) {
+ var parse = require_parse();
+ var eq = require_eq();
+ var diff = (version1, version2) => {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ const v1 = parse(version1);
+ const v2 = parse(version2);
+ const hasPre = v1.prerelease.length || v2.prerelease.length;
+ const prefix = hasPre ? "pre" : "";
+ const defaultResult = hasPre ? "prerelease" : "";
+ for (const key in v1) {
+ if (key === "major" || key === "minor" || key === "patch") {
+ if (v1[key] !== v2[key]) {
+ return prefix + key;
+ }
+ }
+ }
+ return defaultResult;
+ }
+ };
+ module.exports = diff;
+ }
+ });
+
+ // node_modules/semver/functions/major.js
+ var require_major = __commonJS({
+ "node_modules/semver/functions/major.js"(exports, module) {
+ var SemVer = require_semver();
+ var major = (a, loose) => new SemVer(a, loose).major;
+ module.exports = major;
+ }
+ });
+
+ // node_modules/semver/functions/minor.js
+ var require_minor = __commonJS({
+ "node_modules/semver/functions/minor.js"(exports, module) {
+ var SemVer = require_semver();
+ var minor = (a, loose) => new SemVer(a, loose).minor;
+ module.exports = minor;
+ }
+ });
+
+ // node_modules/semver/functions/patch.js
+ var require_patch = __commonJS({
+ "node_modules/semver/functions/patch.js"(exports, module) {
+ var SemVer = require_semver();
+ var patch = (a, loose) => new SemVer(a, loose).patch;
+ module.exports = patch;
+ }
+ });
+
+ // node_modules/semver/functions/prerelease.js
+ var require_prerelease = __commonJS({
+ "node_modules/semver/functions/prerelease.js"(exports, module) {
+ var parse = require_parse();
+ var prerelease = (version, options) => {
+ const parsed = parse(version, options);
+ return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+ };
+ module.exports = prerelease;
+ }
+ });
+
+ // node_modules/semver/functions/rcompare.js
+ var require_rcompare = __commonJS({
+ "node_modules/semver/functions/rcompare.js"(exports, module) {
+ var compare = require_compare();
+ var rcompare = (a, b, loose) => compare(b, a, loose);
+ module.exports = rcompare;
+ }
+ });
+
+ // node_modules/semver/functions/compare-loose.js
+ var require_compare_loose = __commonJS({
+ "node_modules/semver/functions/compare-loose.js"(exports, module) {
+ var compare = require_compare();
+ var compareLoose = (a, b) => compare(a, b, true);
+ module.exports = compareLoose;
+ }
+ });
+
+ // node_modules/semver/functions/compare-build.js
+ var require_compare_build = __commonJS({
+ "node_modules/semver/functions/compare-build.js"(exports, module) {
+ var SemVer = require_semver();
+ var compareBuild = (a, b, loose) => {
+ const versionA = new SemVer(a, loose);
+ const versionB = new SemVer(b, loose);
+ return versionA.compare(versionB) || versionA.compareBuild(versionB);
+ };
+ module.exports = compareBuild;
+ }
+ });
+
+ // node_modules/semver/functions/sort.js
+ var require_sort = __commonJS({
+ "node_modules/semver/functions/sort.js"(exports, module) {
+ var compareBuild = require_compare_build();
+ var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+ module.exports = sort;
+ }
+ });
+
+ // node_modules/semver/functions/rsort.js
+ var require_rsort = __commonJS({
+ "node_modules/semver/functions/rsort.js"(exports, module) {
+ var compareBuild = require_compare_build();
+ var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+ module.exports = rsort;
+ }
+ });
+
+ // node_modules/semver/functions/gt.js
+ var require_gt = __commonJS({
+ "node_modules/semver/functions/gt.js"(exports, module) {
+ var compare = require_compare();
+ var gt = (a, b, loose) => compare(a, b, loose) > 0;
+ module.exports = gt;
+ }
+ });
+
+ // node_modules/semver/functions/lt.js
+ var require_lt = __commonJS({
+ "node_modules/semver/functions/lt.js"(exports, module) {
+ var compare = require_compare();
+ var lt = (a, b, loose) => compare(a, b, loose) < 0;
+ module.exports = lt;
+ }
+ });
+
+ // node_modules/semver/functions/neq.js
+ var require_neq = __commonJS({
+ "node_modules/semver/functions/neq.js"(exports, module) {
+ var compare = require_compare();
+ var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+ module.exports = neq;
+ }
+ });
+
+ // node_modules/semver/functions/gte.js
+ var require_gte = __commonJS({
+ "node_modules/semver/functions/gte.js"(exports, module) {
+ var compare = require_compare();
+ var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+ module.exports = gte;
+ }
+ });
+
+ // node_modules/semver/functions/lte.js
+ var require_lte = __commonJS({
+ "node_modules/semver/functions/lte.js"(exports, module) {
+ var compare = require_compare();
+ var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+ module.exports = lte;
+ }
+ });
+
+ // node_modules/semver/functions/cmp.js
+ var require_cmp = __commonJS({
+ "node_modules/semver/functions/cmp.js"(exports, module) {
+ var eq = require_eq();
+ var neq = require_neq();
+ var gt = require_gt();
+ var gte = require_gte();
+ var lt = require_lt();
+ var lte = require_lte();
+ var cmp = (a, op, b, loose) => {
+ switch (op) {
+ case "===":
+ if (typeof a === "object") {
+ a = a.version;
+ }
+ if (typeof b === "object") {
+ b = b.version;
+ }
+ return a === b;
+ case "!==":
+ if (typeof a === "object") {
+ a = a.version;
+ }
+ if (typeof b === "object") {
+ b = b.version;
+ }
+ return a !== b;
+ case "":
+ case "=":
+ case "==":
+ return eq(a, b, loose);
+ case "!=":
+ return neq(a, b, loose);
+ case ">":
+ return gt(a, b, loose);
+ case ">=":
+ return gte(a, b, loose);
+ case "<":
+ return lt(a, b, loose);
+ case "<=":
+ return lte(a, b, loose);
+ default:
+ throw new TypeError(`Invalid operator: ${op}`);
+ }
+ };
+ module.exports = cmp;
+ }
+ });
+
+ // node_modules/semver/functions/coerce.js
+ var require_coerce = __commonJS({
+ "node_modules/semver/functions/coerce.js"(exports, module) {
+ var SemVer = require_semver();
+ var parse = require_parse();
+ var { re, t } = require_re();
+ var coerce = (version, options) => {
+ if (version instanceof SemVer) {
+ return version;
+ }
+ if (typeof version === "number") {
+ version = String(version);
+ }
+ if (typeof version !== "string") {
+ return null;
+ }
+ options = options || {};
+ let match = null;
+ if (!options.rtl) {
+ match = version.match(re[t.COERCE]);
+ } else {
+ let next;
+ while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+ if (!match || next.index + next[0].length !== match.index + match[0].length) {
+ match = next;
+ }
+ re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+ }
+ re[t.COERCERTL].lastIndex = -1;
+ }
+ if (match === null) {
+ return null;
+ }
+ return parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
+ };
+ module.exports = coerce;
+ }
+ });
+
+ // node_modules/yallist/iterator.js
+ var require_iterator = __commonJS({
+ "node_modules/yallist/iterator.js"(exports, module) {
+ "use strict";
+ module.exports = function(Yallist) {
+ Yallist.prototype[Symbol.iterator] = function* () {
+ for (let walker = this.head; walker; walker = walker.next) {
+ yield walker.value;
+ }
+ };
+ };
+ }
+ });
+
+ // node_modules/yallist/yallist.js
+ var require_yallist = __commonJS({
+ "node_modules/yallist/yallist.js"(exports, module) {
+ "use strict";
+ module.exports = Yallist;
+ Yallist.Node = Node;
+ Yallist.create = Yallist;
+ function Yallist(list) {
+ var self = this;
+ if (!(self instanceof Yallist)) {
+ self = new Yallist();
+ }
+ self.tail = null;
+ self.head = null;
+ self.length = 0;
+ if (list && typeof list.forEach === "function") {
+ list.forEach(function(item) {
+ self.push(item);
+ });
+ } else if (arguments.length > 0) {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ self.push(arguments[i]);
+ }
+ }
+ return self;
+ }
+ Yallist.prototype.removeNode = function(node) {
+ if (node.list !== this) {
+ throw new Error("removing node which does not belong to this list");
+ }
+ var next = node.next;
+ var prev = node.prev;
+ if (next) {
+ next.prev = prev;
+ }
+ if (prev) {
+ prev.next = next;
+ }
+ if (node === this.head) {
+ this.head = next;
+ }
+ if (node === this.tail) {
+ this.tail = prev;
+ }
+ node.list.length--;
+ node.next = null;
+ node.prev = null;
+ node.list = null;
+ return next;
+ };
+ Yallist.prototype.unshiftNode = function(node) {
+ if (node === this.head) {
+ return;
+ }
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+ var head = this.head;
+ node.list = this;
+ node.next = head;
+ if (head) {
+ head.prev = node;
+ }
+ this.head = node;
+ if (!this.tail) {
+ this.tail = node;
+ }
+ this.length++;
+ };
+ Yallist.prototype.pushNode = function(node) {
+ if (node === this.tail) {
+ return;
+ }
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+ var tail = this.tail;
+ node.list = this;
+ node.prev = tail;
+ if (tail) {
+ tail.next = node;
+ }
+ this.tail = node;
+ if (!this.head) {
+ this.head = node;
+ }
+ this.length++;
+ };
+ Yallist.prototype.push = function() {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ push(this, arguments[i]);
+ }
+ return this.length;
+ };
+ Yallist.prototype.unshift = function() {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ unshift(this, arguments[i]);
+ }
+ return this.length;
+ };
+ Yallist.prototype.pop = function() {
+ if (!this.tail) {
+ return void 0;
+ }
+ var res = this.tail.value;
+ this.tail = this.tail.prev;
+ if (this.tail) {
+ this.tail.next = null;
+ } else {
+ this.head = null;
+ }
+ this.length--;
+ return res;
+ };
+ Yallist.prototype.shift = function() {
+ if (!this.head) {
+ return void 0;
+ }
+ var res = this.head.value;
+ this.head = this.head.next;
+ if (this.head) {
+ this.head.prev = null;
+ } else {
+ this.tail = null;
+ }
+ this.length--;
+ return res;
+ };
+ Yallist.prototype.forEach = function(fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.head, i = 0; walker !== null; i++) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.next;
+ }
+ };
+ Yallist.prototype.forEachReverse = function(fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.prev;
+ }
+ };
+ Yallist.prototype.get = function(n) {
+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+ walker = walker.next;
+ }
+ if (i === n && walker !== null) {
+ return walker.value;
+ }
+ };
+ Yallist.prototype.getReverse = function(n) {
+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+ walker = walker.prev;
+ }
+ if (i === n && walker !== null) {
+ return walker.value;
+ }
+ };
+ Yallist.prototype.map = function(fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.head; walker !== null; ) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.next;
+ }
+ return res;
+ };
+ Yallist.prototype.mapReverse = function(fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.tail; walker !== null; ) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.prev;
+ }
+ return res;
+ };
+ Yallist.prototype.reduce = function(fn, initial) {
+ var acc;
+ var walker = this.head;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.head) {
+ walker = this.head.next;
+ acc = this.head.value;
+ } else {
+ throw new TypeError("Reduce of empty list with no initial value");
+ }
+ for (var i = 0; walker !== null; i++) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.next;
+ }
+ return acc;
+ };
+ Yallist.prototype.reduceReverse = function(fn, initial) {
+ var acc;
+ var walker = this.tail;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.tail) {
+ walker = this.tail.prev;
+ acc = this.tail.value;
+ } else {
+ throw new TypeError("Reduce of empty list with no initial value");
+ }
+ for (var i = this.length - 1; walker !== null; i--) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.prev;
+ }
+ return acc;
+ };
+ Yallist.prototype.toArray = function() {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.head; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.next;
+ }
+ return arr;
+ };
+ Yallist.prototype.toArrayReverse = function() {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.tail; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.prev;
+ }
+ return arr;
+ };
+ Yallist.prototype.slice = function(from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret;
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+ walker = walker.next;
+ }
+ for (; walker !== null && i < to; i++, walker = walker.next) {
+ ret.push(walker.value);
+ }
+ return ret;
+ };
+ Yallist.prototype.sliceReverse = function(from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret;
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+ walker = walker.prev;
+ }
+ for (; walker !== null && i > from; i--, walker = walker.prev) {
+ ret.push(walker.value);
+ }
+ return ret;
+ };
+ Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
+ if (start > this.length) {
+ start = this.length - 1;
+ }
+ if (start < 0) {
+ start = this.length + start;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+ walker = walker.next;
+ }
+ var ret = [];
+ for (var i = 0; walker && i < deleteCount; i++) {
+ ret.push(walker.value);
+ walker = this.removeNode(walker);
+ }
+ if (walker === null) {
+ walker = this.tail;
+ }
+ if (walker !== this.head && walker !== this.tail) {
+ walker = walker.prev;
+ }
+ for (var i = 0; i < nodes.length; i++) {
+ walker = insert(this, walker, nodes[i]);
+ }
+ return ret;
+ };
+ Yallist.prototype.reverse = function() {
+ var head = this.head;
+ var tail = this.tail;
+ for (var walker = head; walker !== null; walker = walker.prev) {
+ var p = walker.prev;
+ walker.prev = walker.next;
+ walker.next = p;
+ }
+ this.head = tail;
+ this.tail = head;
+ return this;
+ };
+ function insert(self, node, value) {
+ var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
+ if (inserted.next === null) {
+ self.tail = inserted;
+ }
+ if (inserted.prev === null) {
+ self.head = inserted;
+ }
+ self.length++;
+ return inserted;
+ }
+ function push(self, item) {
+ self.tail = new Node(item, self.tail, null, self);
+ if (!self.head) {
+ self.head = self.tail;
+ }
+ self.length++;
+ }
+ function unshift(self, item) {
+ self.head = new Node(item, null, self.head, self);
+ if (!self.tail) {
+ self.tail = self.head;
+ }
+ self.length++;
+ }
+ function Node(value, prev, next, list) {
+ if (!(this instanceof Node)) {
+ return new Node(value, prev, next, list);
+ }
+ this.list = list;
+ this.value = value;
+ if (prev) {
+ prev.next = this;
+ this.prev = prev;
+ } else {
+ this.prev = null;
+ }
+ if (next) {
+ next.prev = this;
+ this.next = next;
+ } else {
+ this.next = null;
+ }
+ }
+ try {
+ require_iterator()(Yallist);
+ } catch (er) {
+ }
+ }
+ });
+
+ // node_modules/lru-cache/index.js
+ var require_lru_cache = __commonJS({
+ "node_modules/lru-cache/index.js"(exports, module) {
+ "use strict";
+ var Yallist = require_yallist();
+ var MAX = Symbol("max");
+ var LENGTH = Symbol("length");
+ var LENGTH_CALCULATOR = Symbol("lengthCalculator");
+ var ALLOW_STALE = Symbol("allowStale");
+ var MAX_AGE = Symbol("maxAge");
+ var DISPOSE = Symbol("dispose");
+ var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
+ var LRU_LIST = Symbol("lruList");
+ var CACHE = Symbol("cache");
+ var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
+ var naiveLength = () => 1;
+ var LRUCache = class {
+ constructor(options) {
+ if (typeof options === "number")
+ options = { max: options };
+ if (!options)
+ options = {};
+ if (options.max && (typeof options.max !== "number" || options.max < 0))
+ throw new TypeError("max must be a non-negative number");
+ const max = this[MAX] = options.max || Infinity;
+ const lc = options.length || naiveLength;
+ this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
+ this[ALLOW_STALE] = options.stale || false;
+ if (options.maxAge && typeof options.maxAge !== "number")
+ throw new TypeError("maxAge must be a number");
+ this[MAX_AGE] = options.maxAge || 0;
+ this[DISPOSE] = options.dispose;
+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+ this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+ this.reset();
+ }
+ set max(mL) {
+ if (typeof mL !== "number" || mL < 0)
+ throw new TypeError("max must be a non-negative number");
+ this[MAX] = mL || Infinity;
+ trim(this);
+ }
+ get max() {
+ return this[MAX];
+ }
+ set allowStale(allowStale) {
+ this[ALLOW_STALE] = !!allowStale;
+ }
+ get allowStale() {
+ return this[ALLOW_STALE];
+ }
+ set maxAge(mA) {
+ if (typeof mA !== "number")
+ throw new TypeError("maxAge must be a non-negative number");
+ this[MAX_AGE] = mA;
+ trim(this);
+ }
+ get maxAge() {
+ return this[MAX_AGE];
+ }
+ set lengthCalculator(lC) {
+ if (typeof lC !== "function")
+ lC = naiveLength;
+ if (lC !== this[LENGTH_CALCULATOR]) {
+ this[LENGTH_CALCULATOR] = lC;
+ this[LENGTH] = 0;
+ this[LRU_LIST].forEach((hit) => {
+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+ this[LENGTH] += hit.length;
+ });
+ }
+ trim(this);
+ }
+ get lengthCalculator() {
+ return this[LENGTH_CALCULATOR];
+ }
+ get length() {
+ return this[LENGTH];
+ }
+ get itemCount() {
+ return this[LRU_LIST].length;
+ }
+ rforEach(fn, thisp) {
+ thisp = thisp || this;
+ for (let walker = this[LRU_LIST].tail; walker !== null; ) {
+ const prev = walker.prev;
+ forEachStep(this, fn, walker, thisp);
+ walker = prev;
+ }
+ }
+ forEach(fn, thisp) {
+ thisp = thisp || this;
+ for (let walker = this[LRU_LIST].head; walker !== null; ) {
+ const next = walker.next;
+ forEachStep(this, fn, walker, thisp);
+ walker = next;
+ }
+ }
+ keys() {
+ return this[LRU_LIST].toArray().map((k) => k.key);
+ }
+ values() {
+ return this[LRU_LIST].toArray().map((k) => k.value);
+ }
+ reset() {
+ if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+ this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
+ }
+ this[CACHE] = /* @__PURE__ */ new Map();
+ this[LRU_LIST] = new Yallist();
+ this[LENGTH] = 0;
+ }
+ dump() {
+ return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
+ k: hit.key,
+ v: hit.value,
+ e: hit.now + (hit.maxAge || 0)
+ }).toArray().filter((h) => h);
+ }
+ dumpLru() {
+ return this[LRU_LIST];
+ }
+ set(key, value, maxAge) {
+ maxAge = maxAge || this[MAX_AGE];
+ if (maxAge && typeof maxAge !== "number")
+ throw new TypeError("maxAge must be a number");
+ const now = maxAge ? Date.now() : 0;
+ const len = this[LENGTH_CALCULATOR](value, key);
+ if (this[CACHE].has(key)) {
+ if (len > this[MAX]) {
+ del(this, this[CACHE].get(key));
+ return false;
+ }
+ const node = this[CACHE].get(key);
+ const item = node.value;
+ if (this[DISPOSE]) {
+ if (!this[NO_DISPOSE_ON_SET])
+ this[DISPOSE](key, item.value);
+ }
+ item.now = now;
+ item.maxAge = maxAge;
+ item.value = value;
+ this[LENGTH] += len - item.length;
+ item.length = len;
+ this.get(key);
+ trim(this);
+ return true;
+ }
+ const hit = new Entry(key, value, len, now, maxAge);
+ if (hit.length > this[MAX]) {
+ if (this[DISPOSE])
+ this[DISPOSE](key, value);
+ return false;
+ }
+ this[LENGTH] += hit.length;
+ this[LRU_LIST].unshift(hit);
+ this[CACHE].set(key, this[LRU_LIST].head);
+ trim(this);
+ return true;
+ }
+ has(key) {
+ if (!this[CACHE].has(key))
+ return false;
+ const hit = this[CACHE].get(key).value;
+ return !isStale(this, hit);
+ }
+ get(key) {
+ return get(this, key, true);
+ }
+ peek(key) {
+ return get(this, key, false);
+ }
+ pop() {
+ const node = this[LRU_LIST].tail;
+ if (!node)
+ return null;
+ del(this, node);
+ return node.value;
+ }
+ del(key) {
+ del(this, this[CACHE].get(key));
+ }
+ load(arr) {
+ this.reset();
+ const now = Date.now();
+ for (let l = arr.length - 1; l >= 0; l--) {
+ const hit = arr[l];
+ const expiresAt = hit.e || 0;
+ if (expiresAt === 0)
+ this.set(hit.k, hit.v);
+ else {
+ const maxAge = expiresAt - now;
+ if (maxAge > 0) {
+ this.set(hit.k, hit.v, maxAge);
+ }
+ }
+ }
+ }
+ prune() {
+ this[CACHE].forEach((value, key) => get(this, key, false));
+ }
+ };
+ var get = (self, key, doUse) => {
+ const node = self[CACHE].get(key);
+ if (node) {
+ const hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE])
+ return void 0;
+ } else {
+ if (doUse) {
+ if (self[UPDATE_AGE_ON_GET])
+ node.value.now = Date.now();
+ self[LRU_LIST].unshiftNode(node);
+ }
+ }
+ return hit.value;
+ }
+ };
+ var isStale = (self, hit) => {
+ if (!hit || !hit.maxAge && !self[MAX_AGE])
+ return false;
+ const diff = Date.now() - hit.now;
+ return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
+ };
+ var trim = (self) => {
+ if (self[LENGTH] > self[MAX]) {
+ for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) {
+ const prev = walker.prev;
+ del(self, walker);
+ walker = prev;
+ }
+ }
+ };
+ var del = (self, node) => {
+ if (node) {
+ const hit = node.value;
+ if (self[DISPOSE])
+ self[DISPOSE](hit.key, hit.value);
+ self[LENGTH] -= hit.length;
+ self[CACHE].delete(hit.key);
+ self[LRU_LIST].removeNode(node);
+ }
+ };
+ var Entry = class {
+ constructor(key, value, length, now, maxAge) {
+ this.key = key;
+ this.value = value;
+ this.length = length;
+ this.now = now;
+ this.maxAge = maxAge || 0;
+ }
+ };
+ var forEachStep = (self, fn, node, thisp) => {
+ let hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE])
+ hit = void 0;
+ }
+ if (hit)
+ fn.call(thisp, hit.value, hit.key, self);
+ };
+ module.exports = LRUCache;
+ }
+ });
+
+ // node_modules/semver/classes/range.js
+ var require_range = __commonJS({
+ "node_modules/semver/classes/range.js"(exports, module) {
+ var Range = class {
+ constructor(range, options) {
+ options = parseOptions(options);
+ if (range instanceof Range) {
+ if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+ return range;
+ } else {
+ return new Range(range.raw, options);
+ }
+ }
+ if (range instanceof Comparator) {
+ this.raw = range.value;
+ this.set = [[range]];
+ this.format();
+ return this;
+ }
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+ this.raw = range;
+ this.set = range.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+ if (!this.set.length) {
+ throw new TypeError(`Invalid SemVer Range: ${range}`);
+ }
+ if (this.set.length > 1) {
+ const first = this.set[0];
+ this.set = this.set.filter((c) => !isNullSet(c[0]));
+ if (this.set.length === 0) {
+ this.set = [first];
+ } else if (this.set.length > 1) {
+ for (const c of this.set) {
+ if (c.length === 1 && isAny(c[0])) {
+ this.set = [c];
+ break;
+ }
+ }
+ }
+ }
+ this.format();
+ }
+ format() {
+ this.range = this.set.map((comps) => {
+ return comps.join(" ").trim();
+ }).join("||").trim();
+ return this.range;
+ }
+ toString() {
+ return this.range;
+ }
+ parseRange(range) {
+ range = range.trim();
+ const memoOpts = Object.keys(this.options).join(",");
+ const memoKey = `parseRange:${memoOpts}:${range}`;
+ const cached = cache.get(memoKey);
+ if (cached) {
+ return cached;
+ }
+ const loose = this.options.loose;
+ const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+ debug("hyphen replace", range);
+ range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+ debug("comparator trim", range);
+ range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+ range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+ range = range.split(/\s+/).join(" ");
+ let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+ if (loose) {
+ rangeList = rangeList.filter((comp) => {
+ debug("loose invalid filter", comp, this.options);
+ return !!comp.match(re[t.COMPARATORLOOSE]);
+ });
+ }
+ debug("range list", rangeList);
+ const rangeMap = /* @__PURE__ */ new Map();
+ const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+ for (const comp of comparators) {
+ if (isNullSet(comp)) {
+ return [comp];
+ }
+ rangeMap.set(comp.value, comp);
+ }
+ if (rangeMap.size > 1 && rangeMap.has("")) {
+ rangeMap.delete("");
+ }
+ const result = [...rangeMap.values()];
+ cache.set(memoKey, result);
+ return result;
+ }
+ intersects(range, options) {
+ if (!(range instanceof Range)) {
+ throw new TypeError("a Range is required");
+ }
+ return this.set.some((thisComparators) => {
+ return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+ return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+ return rangeComparators.every((rangeComparator) => {
+ return thisComparator.intersects(rangeComparator, options);
+ });
+ });
+ });
+ });
+ }
+ test(version) {
+ if (!version) {
+ return false;
+ }
+ if (typeof version === "string") {
+ try {
+ version = new SemVer(version, this.options);
+ } catch (er) {
+ return false;
+ }
+ }
+ for (let i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version, this.options)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ };
+ module.exports = Range;
+ var LRU = require_lru_cache();
+ var cache = new LRU({ max: 1e3 });
+ var parseOptions = require_parse_options();
+ var Comparator = require_comparator();
+ var debug = require_debug();
+ var SemVer = require_semver();
+ var {
+ re,
+ t,
+ comparatorTrimReplace,
+ tildeTrimReplace,
+ caretTrimReplace
+ } = require_re();
+ var isNullSet = (c) => c.value === "<0.0.0-0";
+ var isAny = (c) => c.value === "";
+ var isSatisfiable = (comparators, options) => {
+ let result = true;
+ const remainingComparators = comparators.slice();
+ let testComparator = remainingComparators.pop();
+ while (result && remainingComparators.length) {
+ result = remainingComparators.every((otherComparator) => {
+ return testComparator.intersects(otherComparator, options);
+ });
+ testComparator = remainingComparators.pop();
+ }
+ return result;
+ };
+ var parseComparator = (comp, options) => {
+ debug("comp", comp, options);
+ comp = replaceCarets(comp, options);
+ debug("caret", comp);
+ comp = replaceTildes(comp, options);
+ debug("tildes", comp);
+ comp = replaceXRanges(comp, options);
+ debug("xrange", comp);
+ comp = replaceStars(comp, options);
+ debug("stars", comp);
+ return comp;
+ };
+ var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+ var replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c) => {
+ return replaceTilde(c, options);
+ }).join(" ");
+ var replaceTilde = (comp, options) => {
+ const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+ return comp.replace(r, (_, M, m, p, pr) => {
+ debug("tilde", comp, _, M, m, p, pr);
+ let ret;
+ if (isX(M)) {
+ ret = "";
+ } else if (isX(m)) {
+ ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+ } else if (isX(p)) {
+ ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+ } else if (pr) {
+ debug("replaceTilde pr", pr);
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+ } else {
+ ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+ }
+ debug("tilde return", ret);
+ return ret;
+ });
+ };
+ var replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c) => {
+ return replaceCaret(c, options);
+ }).join(" ");
+ var replaceCaret = (comp, options) => {
+ debug("caret", comp, options);
+ const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+ const z = options.includePrerelease ? "-0" : "";
+ return comp.replace(r, (_, M, m, p, pr) => {
+ debug("caret", comp, _, M, m, p, pr);
+ let ret;
+ if (isX(M)) {
+ ret = "";
+ } else if (isX(m)) {
+ ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+ } else if (isX(p)) {
+ if (M === "0") {
+ ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+ } else {
+ ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+ }
+ } else if (pr) {
+ debug("replaceCaret pr", pr);
+ if (M === "0") {
+ if (m === "0") {
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+ } else {
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+ }
+ } else {
+ ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+ }
+ } else {
+ debug("no pr");
+ if (M === "0") {
+ if (m === "0") {
+ ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+ } else {
+ ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+ }
+ } else {
+ ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+ }
+ }
+ debug("caret return", ret);
+ return ret;
+ });
+ };
+ var replaceXRanges = (comp, options) => {
+ debug("replaceXRanges", comp, options);
+ return comp.split(/\s+/).map((c) => {
+ return replaceXRange(c, options);
+ }).join(" ");
+ };
+ var replaceXRange = (comp, options) => {
+ comp = comp.trim();
+ const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+ return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+ debug("xRange", comp, ret, gtlt, M, m, p, pr);
+ const xM = isX(M);
+ const xm = xM || isX(m);
+ const xp = xm || isX(p);
+ const anyX = xp;
+ if (gtlt === "=" && anyX) {
+ gtlt = "";
+ }
+ pr = options.includePrerelease ? "-0" : "";
+ if (xM) {
+ if (gtlt === ">" || gtlt === "<") {
+ ret = "<0.0.0-0";
+ } else {
+ ret = "*";
+ }
+ } else if (gtlt && anyX) {
+ if (xm) {
+ m = 0;
+ }
+ p = 0;
+ if (gtlt === ">") {
+ gtlt = ">=";
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === "<=") {
+ gtlt = "<";
+ if (xm) {
+ M = +M + 1;
+ } else {
+ m = +m + 1;
+ }
+ }
+ if (gtlt === "<") {
+ pr = "-0";
+ }
+ ret = `${gtlt + M}.${m}.${p}${pr}`;
+ } else if (xm) {
+ ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+ } else if (xp) {
+ ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+ }
+ debug("xRange return", ret);
+ return ret;
+ });
+ };
+ var replaceStars = (comp, options) => {
+ debug("replaceStars", comp, options);
+ return comp.trim().replace(re[t.STAR], "");
+ };
+ var replaceGTE0 = (comp, options) => {
+ debug("replaceGTE0", comp, options);
+ return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+ };
+ var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
+ if (isX(fM)) {
+ from = "";
+ } else if (isX(fm)) {
+ from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+ } else if (isX(fp)) {
+ from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+ } else if (fpr) {
+ from = `>=${from}`;
+ } else {
+ from = `>=${from}${incPr ? "-0" : ""}`;
+ }
+ if (isX(tM)) {
+ to = "";
+ } else if (isX(tm)) {
+ to = `<${+tM + 1}.0.0-0`;
+ } else if (isX(tp)) {
+ to = `<${tM}.${+tm + 1}.0-0`;
+ } else if (tpr) {
+ to = `<=${tM}.${tm}.${tp}-${tpr}`;
+ } else if (incPr) {
+ to = `<${tM}.${tm}.${+tp + 1}-0`;
+ } else {
+ to = `<=${to}`;
+ }
+ return `${from} ${to}`.trim();
+ };
+ var testSet = (set, version, options) => {
+ for (let i = 0; i < set.length; i++) {
+ if (!set[i].test(version)) {
+ return false;
+ }
+ }
+ if (version.prerelease.length && !options.includePrerelease) {
+ for (let i = 0; i < set.length; i++) {
+ debug(set[i].semver);
+ if (set[i].semver === Comparator.ANY) {
+ continue;
+ }
+ if (set[i].semver.prerelease.length > 0) {
+ const allowed = set[i].semver;
+ if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ return true;
+ };
+ }
+ });
+
+ // node_modules/semver/classes/comparator.js
+ var require_comparator = __commonJS({
+ "node_modules/semver/classes/comparator.js"(exports, module) {
+ var ANY = Symbol("SemVer ANY");
+ var Comparator = class {
+ static get ANY() {
+ return ANY;
+ }
+ constructor(comp, options) {
+ options = parseOptions(options);
+ if (comp instanceof Comparator) {
+ if (comp.loose === !!options.loose) {
+ return comp;
+ } else {
+ comp = comp.value;
+ }
+ }
+ debug("comparator", comp, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.parse(comp);
+ if (this.semver === ANY) {
+ this.value = "";
+ } else {
+ this.value = this.operator + this.semver.version;
+ }
+ debug("comp", this);
+ }
+ parse(comp) {
+ const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+ const m = comp.match(r);
+ if (!m) {
+ throw new TypeError(`Invalid comparator: ${comp}`);
+ }
+ this.operator = m[1] !== void 0 ? m[1] : "";
+ if (this.operator === "=") {
+ this.operator = "";
+ }
+ if (!m[2]) {
+ this.semver = ANY;
+ } else {
+ this.semver = new SemVer(m[2], this.options.loose);
+ }
+ }
+ toString() {
+ return this.value;
+ }
+ test(version) {
+ debug("Comparator.test", version, this.options.loose);
+ if (this.semver === ANY || version === ANY) {
+ return true;
+ }
+ if (typeof version === "string") {
+ try {
+ version = new SemVer(version, this.options);
+ } catch (er) {
+ return false;
+ }
+ }
+ return cmp(version, this.operator, this.semver, this.options);
+ }
+ intersects(comp, options) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError("a Comparator is required");
+ }
+ if (!options || typeof options !== "object") {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ };
+ }
+ if (this.operator === "") {
+ if (this.value === "") {
+ return true;
+ }
+ return new Range(comp.value, options).test(this.value);
+ } else if (comp.operator === "") {
+ if (comp.value === "") {
+ return true;
+ }
+ return new Range(this.value, options).test(comp.semver);
+ }
+ const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
+ const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
+ const sameSemVer = this.semver.version === comp.semver.version;
+ const differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
+ const oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
+ const oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
+ return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+ }
+ };
+ module.exports = Comparator;
+ var parseOptions = require_parse_options();
+ var { re, t } = require_re();
+ var cmp = require_cmp();
+ var debug = require_debug();
+ var SemVer = require_semver();
+ var Range = require_range();
+ }
+ });
+
+ // node_modules/semver/functions/satisfies.js
+ var require_satisfies = __commonJS({
+ "node_modules/semver/functions/satisfies.js"(exports, module) {
+ var Range = require_range();
+ var satisfies = (version, range, options) => {
+ try {
+ range = new Range(range, options);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version);
+ };
+ module.exports = satisfies;
+ }
+ });
+
+ // node_modules/semver/ranges/to-comparators.js
+ var require_to_comparators = __commonJS({
+ "node_modules/semver/ranges/to-comparators.js"(exports, module) {
+ var Range = require_range();
+ var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+ module.exports = toComparators;
+ }
+ });
+
+ // node_modules/semver/ranges/max-satisfying.js
+ var require_max_satisfying = __commonJS({
+ "node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var maxSatisfying = (versions, range, options) => {
+ let max = null;
+ let maxSV = null;
+ let rangeObj = null;
+ try {
+ rangeObj = new Range(range, options);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach((v) => {
+ if (rangeObj.test(v)) {
+ if (!max || maxSV.compare(v) === -1) {
+ max = v;
+ maxSV = new SemVer(max, options);
+ }
+ }
+ });
+ return max;
+ };
+ module.exports = maxSatisfying;
+ }
+ });
+
+ // node_modules/semver/ranges/min-satisfying.js
+ var require_min_satisfying = __commonJS({
+ "node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var minSatisfying = (versions, range, options) => {
+ let min = null;
+ let minSV = null;
+ let rangeObj = null;
+ try {
+ rangeObj = new Range(range, options);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach((v) => {
+ if (rangeObj.test(v)) {
+ if (!min || minSV.compare(v) === 1) {
+ min = v;
+ minSV = new SemVer(min, options);
+ }
+ }
+ });
+ return min;
+ };
+ module.exports = minSatisfying;
+ }
+ });
+
+ // node_modules/semver/ranges/min-version.js
+ var require_min_version = __commonJS({
+ "node_modules/semver/ranges/min-version.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var gt = require_gt();
+ var minVersion = (range, loose) => {
+ range = new Range(range, loose);
+ let minver = new SemVer("0.0.0");
+ if (range.test(minver)) {
+ return minver;
+ }
+ minver = new SemVer("0.0.0-0");
+ if (range.test(minver)) {
+ return minver;
+ }
+ minver = null;
+ for (let i = 0; i < range.set.length; ++i) {
+ const comparators = range.set[i];
+ let setMin = null;
+ comparators.forEach((comparator) => {
+ const compver = new SemVer(comparator.semver.version);
+ switch (comparator.operator) {
+ case ">":
+ if (compver.prerelease.length === 0) {
+ compver.patch++;
+ } else {
+ compver.prerelease.push(0);
+ }
+ compver.raw = compver.format();
+ case "":
+ case ">=":
+ if (!setMin || gt(compver, setMin)) {
+ setMin = compver;
+ }
+ break;
+ case "<":
+ case "<=":
+ break;
+ default:
+ throw new Error(`Unexpected operation: ${comparator.operator}`);
+ }
+ });
+ if (setMin && (!minver || gt(minver, setMin))) {
+ minver = setMin;
+ }
+ }
+ if (minver && range.test(minver)) {
+ return minver;
+ }
+ return null;
+ };
+ module.exports = minVersion;
+ }
+ });
+
+ // node_modules/semver/ranges/valid.js
+ var require_valid2 = __commonJS({
+ "node_modules/semver/ranges/valid.js"(exports, module) {
+ var Range = require_range();
+ var validRange = (range, options) => {
+ try {
+ return new Range(range, options).range || "*";
+ } catch (er) {
+ return null;
+ }
+ };
+ module.exports = validRange;
+ }
+ });
+
+ // node_modules/semver/ranges/outside.js
+ var require_outside = __commonJS({
+ "node_modules/semver/ranges/outside.js"(exports, module) {
+ var SemVer = require_semver();
+ var Comparator = require_comparator();
+ var { ANY } = Comparator;
+ var Range = require_range();
+ var satisfies = require_satisfies();
+ var gt = require_gt();
+ var lt = require_lt();
+ var lte = require_lte();
+ var gte = require_gte();
+ var outside = (version, range, hilo, options) => {
+ version = new SemVer(version, options);
+ range = new Range(range, options);
+ let gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case ">":
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = ">";
+ ecomp = ">=";
+ break;
+ case "<":
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = "<";
+ ecomp = "<=";
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+ if (satisfies(version, range, options)) {
+ return false;
+ }
+ for (let i = 0; i < range.set.length; ++i) {
+ const comparators = range.set[i];
+ let high = null;
+ let low = null;
+ comparators.forEach((comparator) => {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator(">=0.0.0");
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, options)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, options)) {
+ low = comparator;
+ }
+ });
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+ if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ module.exports = outside;
+ }
+ });
+
+ // node_modules/semver/ranges/gtr.js
+ var require_gtr = __commonJS({
+ "node_modules/semver/ranges/gtr.js"(exports, module) {
+ var outside = require_outside();
+ var gtr = (version, range, options) => outside(version, range, ">", options);
+ module.exports = gtr;
+ }
+ });
+
+ // node_modules/semver/ranges/ltr.js
+ var require_ltr = __commonJS({
+ "node_modules/semver/ranges/ltr.js"(exports, module) {
+ var outside = require_outside();
+ var ltr = (version, range, options) => outside(version, range, "<", options);
+ module.exports = ltr;
+ }
+ });
+
+ // node_modules/semver/ranges/intersects.js
+ var require_intersects = __commonJS({
+ "node_modules/semver/ranges/intersects.js"(exports, module) {
+ var Range = require_range();
+ var intersects = (r1, r2, options) => {
+ r1 = new Range(r1, options);
+ r2 = new Range(r2, options);
+ return r1.intersects(r2);
+ };
+ module.exports = intersects;
+ }
+ });
+
+ // node_modules/semver/ranges/simplify.js
+ var require_simplify = __commonJS({
+ "node_modules/semver/ranges/simplify.js"(exports, module) {
+ var satisfies = require_satisfies();
+ var compare = require_compare();
+ module.exports = (versions, range, options) => {
+ const set = [];
+ let first = null;
+ let prev = null;
+ const v = versions.sort((a, b) => compare(a, b, options));
+ for (const version of v) {
+ const included = satisfies(version, range, options);
+ if (included) {
+ prev = version;
+ if (!first) {
+ first = version;
+ }
+ } else {
+ if (prev) {
+ set.push([first, prev]);
+ }
+ prev = null;
+ first = null;
+ }
+ }
+ if (first) {
+ set.push([first, null]);
+ }
+ const ranges = [];
+ for (const [min, max] of set) {
+ if (min === max) {
+ ranges.push(min);
+ } else if (!max && min === v[0]) {
+ ranges.push("*");
+ } else if (!max) {
+ ranges.push(`>=${min}`);
+ } else if (min === v[0]) {
+ ranges.push(`<=${max}`);
+ } else {
+ ranges.push(`${min} - ${max}`);
+ }
+ }
+ const simplified = ranges.join(" || ");
+ const original = typeof range.raw === "string" ? range.raw : String(range);
+ return simplified.length < original.length ? simplified : range;
+ };
+ }
+ });
+
+ // node_modules/semver/ranges/subset.js
+ var require_subset = __commonJS({
+ "node_modules/semver/ranges/subset.js"(exports, module) {
+ var Range = require_range();
+ var Comparator = require_comparator();
+ var { ANY } = Comparator;
+ var satisfies = require_satisfies();
+ var compare = require_compare();
+ var subset = (sub, dom, options = {}) => {
+ if (sub === dom) {
+ return true;
+ }
+ sub = new Range(sub, options);
+ dom = new Range(dom, options);
+ let sawNonNull = false;
+ OUTER:
+ for (const simpleSub of sub.set) {
+ for (const simpleDom of dom.set) {
+ const isSub = simpleSubset(simpleSub, simpleDom, options);
+ sawNonNull = sawNonNull || isSub !== null;
+ if (isSub) {
+ continue OUTER;
+ }
+ }
+ if (sawNonNull) {
+ return false;
+ }
+ }
+ return true;
+ };
+ var simpleSubset = (sub, dom, options) => {
+ if (sub === dom) {
+ return true;
+ }
+ if (sub.length === 1 && sub[0].semver === ANY) {
+ if (dom.length === 1 && dom[0].semver === ANY) {
+ return true;
+ } else if (options.includePrerelease) {
+ sub = [new Comparator(">=0.0.0-0")];
+ } else {
+ sub = [new Comparator(">=0.0.0")];
+ }
+ }
+ if (dom.length === 1 && dom[0].semver === ANY) {
+ if (options.includePrerelease) {
+ return true;
+ } else {
+ dom = [new Comparator(">=0.0.0")];
+ }
+ }
+ const eqSet = /* @__PURE__ */ new Set();
+ let gt, lt;
+ for (const c of sub) {
+ if (c.operator === ">" || c.operator === ">=") {
+ gt = higherGT(gt, c, options);
+ } else if (c.operator === "<" || c.operator === "<=") {
+ lt = lowerLT(lt, c, options);
+ } else {
+ eqSet.add(c.semver);
+ }
+ }
+ if (eqSet.size > 1) {
+ return null;
+ }
+ let gtltComp;
+ if (gt && lt) {
+ gtltComp = compare(gt.semver, lt.semver, options);
+ if (gtltComp > 0) {
+ return null;
+ } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+ return null;
+ }
+ }
+ for (const eq of eqSet) {
+ if (gt && !satisfies(eq, String(gt), options)) {
+ return null;
+ }
+ if (lt && !satisfies(eq, String(lt), options)) {
+ return null;
+ }
+ for (const c of dom) {
+ if (!satisfies(eq, String(c), options)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ let higher, lower;
+ let hasDomLT, hasDomGT;
+ let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+ let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+ if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+ needDomLTPre = false;
+ }
+ for (const c of dom) {
+ hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+ hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+ if (gt) {
+ if (needDomGTPre) {
+ if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+ needDomGTPre = false;
+ }
+ }
+ if (c.operator === ">" || c.operator === ">=") {
+ higher = higherGT(gt, c, options);
+ if (higher === c && higher !== gt) {
+ return false;
+ }
+ } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+ return false;
+ }
+ }
+ if (lt) {
+ if (needDomLTPre) {
+ if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+ needDomLTPre = false;
+ }
+ }
+ if (c.operator === "<" || c.operator === "<=") {
+ lower = lowerLT(lt, c, options);
+ if (lower === c && lower !== lt) {
+ return false;
+ }
+ } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+ return false;
+ }
+ }
+ if (!c.operator && (lt || gt) && gtltComp !== 0) {
+ return false;
+ }
+ }
+ if (gt && hasDomLT && !lt && gtltComp !== 0) {
+ return false;
+ }
+ if (lt && hasDomGT && !gt && gtltComp !== 0) {
+ return false;
+ }
+ if (needDomGTPre || needDomLTPre) {
+ return false;
+ }
+ return true;
+ };
+ var higherGT = (a, b, options) => {
+ if (!a) {
+ return b;
+ }
+ const comp = compare(a.semver, b.semver, options);
+ return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+ };
+ var lowerLT = (a, b, options) => {
+ if (!a) {
+ return b;
+ }
+ const comp = compare(a.semver, b.semver, options);
+ return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+ };
+ module.exports = subset;
+ }
+ });
+
+ // node_modules/semver/index.js
+ var require_semver2 = __commonJS({
+ "node_modules/semver/index.js"(exports, module) {
+ var internalRe = require_re();
+ module.exports = {
+ re: internalRe.re,
+ src: internalRe.src,
+ tokens: internalRe.t,
+ SEMVER_SPEC_VERSION: require_constants().SEMVER_SPEC_VERSION,
+ SemVer: require_semver(),
+ compareIdentifiers: require_identifiers().compareIdentifiers,
+ rcompareIdentifiers: require_identifiers().rcompareIdentifiers,
+ parse: require_parse(),
+ valid: require_valid(),
+ clean: require_clean(),
+ inc: require_inc(),
+ diff: require_diff(),
+ major: require_major(),
+ minor: require_minor(),
+ patch: require_patch(),
+ prerelease: require_prerelease(),
+ compare: require_compare(),
+ rcompare: require_rcompare(),
+ compareLoose: require_compare_loose(),
+ compareBuild: require_compare_build(),
+ sort: require_sort(),
+ rsort: require_rsort(),
+ gt: require_gt(),
+ lt: require_lt(),
+ eq: require_eq(),
+ neq: require_neq(),
+ gte: require_gte(),
+ lte: require_lte(),
+ cmp: require_cmp(),
+ coerce: require_coerce(),
+ Comparator: require_comparator(),
+ Range: require_range(),
+ satisfies: require_satisfies(),
+ toComparators: require_to_comparators(),
+ maxSatisfying: require_max_satisfying(),
+ minSatisfying: require_min_satisfying(),
+ minVersion: require_min_version(),
+ validRange: require_valid2(),
+ outside: require_outside(),
+ gtr: require_gtr(),
+ ltr: require_ltr(),
+ intersects: require_intersects(),
+ simplifyRange: require_simplify(),
+ subset: require_subset()
+ };
+ }
+ });
+
+ // dep:semver
+ var semver_default = require_semver2();
+ export {
+ semver_default as default
+ };
diff --git a/src/renderer/others/setting-schema.ts b/src/renderer/others/setting-schema.ts
new file mode 100644
index 000000000..af864211c
--- /dev/null
+++ b/src/renderer/others/setting-schema.ts
@@ -0,0 +1,526 @@
+import { cloneDeep } from 'lodash-es'
+import { DEFAULT_EXCLUDE_REGEX } from '@share/misc'
+import { isMacOS, isWindows } from '@fe/support/env'
+import { FLAG_DISABLE_XTERM, FLAG_MAS } from '@fe/support/args'
+import { SettingSchema } from '@fe/types'
+
+const schema: SettingSchema = ({
+ type: 'object',
+ title: 'T_setting-panel.setting',
+ properties: {
+ repos: {
+ defaultValue: [],
+ type: 'array',
+ title: 'T_setting-panel.schema.repos.repos',
+ format: 'table',
+ group: 'repos',
+ items: {
+ type: 'object',
+ title: 'T_setting-panel.schema.repos.repo',
+ properties: {
+ name: {
+ type: 'string',
+ title: 'T_setting-panel.schema.repos.name',
+ defaultValue: '',
+ maxLength: 10,
+ options: {
+ inputAttributes: { placeholder: 'T_setting-panel.schema.repos.name-placeholder' }
+ },
+ },
+ path: {
+ type: 'string',
+ title: 'T_setting-panel.schema.repos.path',
+ openDialogOptions: { properties: ['openDirectory', 'createDirectory'] },
+ options: {
+ inputAttributes: { placeholder: 'T_setting-panel.schema.repos.path-placeholder', style: 'cursor: pointer' }
+ },
+ },
+ enableIndexing: {
+ type: 'boolean',
+ title: 'T_setting-panel.schema.repos.enable-indexing',
+ defaultValue: false,
+ format: 'checkbox',
+ },
+ }
+ },
+ },
+ theme: {
+ defaultValue: 'system',
+ title: 'T_setting-panel.schema.theme',
+ type: 'string',
+ enum: ['system', 'dark', 'light'],
+ options: {
+ enum_titles: ['System', 'Dark', 'Light'],
+ },
+ group: 'appearance',
+ required: true,
+ },
+ language: {
+ defaultValue: 'system',
+ title: 'T_setting-panel.schema.language',
+ type: 'string',
+ enum: ['system', 'en', 'zh-CN', 'zh-TW', 'ru'],
+ options: {
+ enum_titles: ['System', 'English', '简体中文', '繁體中文', 'русский'],
+ },
+ group: 'appearance',
+ required: true,
+ },
+ 'custom-css': {
+ defaultValue: 'github.css',
+ title: 'T_setting-panel.schema.custom-css',
+ type: 'string',
+ enum: ['github.css'],
+ options: {
+ enum_titles: ['github.css'],
+ },
+ group: 'appearance',
+ required: true,
+ },
+ 'view.default-previewer-max-width': {
+ defaultValue: 1024,
+ title: 'T_setting-panel.schema.view.default-previewer-max-width',
+ type: 'number',
+ format: 'number',
+ group: 'appearance',
+ required: true,
+ description: 'T_setting-panel.schema.view.default-previewer-max-width-desc',
+ minimum: 10,
+ maximum: Number.MAX_SAFE_INTEGER,
+ },
+ 'view.default-previewer-font-family': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.view.default-previewer-font-family',
+ type: 'string',
+ group: 'appearance',
+ options: {
+ inputAttributes: { placeholder: 'e.g., \'Courier New\', monospace' }
+ },
+ },
+ 'updater.source': {
+ defaultValue: 'auto',
+ title: 'T_setting-panel.schema.updater.source',
+ type: 'string',
+ enum: ['auto', 'yank-note', 'github'],
+ group: 'other',
+ required: true,
+ },
+ 'plantuml-api': {
+ defaultValue: 'local-png',
+ title: 'T_setting-panel.schema.plantuml-api',
+ type: 'string',
+ enum: [
+ 'local-png',
+ 'local-svg',
+ 'https://www.plantuml.com/plantuml/png/{data}',
+ 'https://www.plantuml.com/plantuml/svg/{data}',
+ ],
+ options: {
+ enum_titles: [
+ 'Local (PNG) - Need Java and Graphviz',
+ 'Local (SVG) - Need Java and Graphviz',
+ 'Online (plantuml.com) - PNG',
+ 'Online (plantuml.com) - SVG',
+ ],
+ },
+ required: true,
+ group: 'other',
+ },
+ 'doc-history.number-limit': {
+ defaultValue: 500,
+ title: 'T_setting-panel.schema.doc-history.number-limit',
+ type: 'number',
+ enum: [0, 10, 20, 50, 100, 200, 500, 1000],
+ options: {
+ enum_titles: ['Disable'],
+ },
+ required: true,
+ group: 'other',
+ },
+ 'search.number-limit': {
+ defaultValue: 700,
+ title: 'T_setting-panel.schema.search.number-limit',
+ type: 'number',
+ enum: [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1300, 1600, 2000],
+ required: true,
+ group: 'other',
+ },
+ 'assets-dir': {
+ defaultValue: './FILES/{docName}',
+ title: 'T_setting-panel.schema.assets-dir',
+ type: 'string',
+ description: 'T_setting-panel.schema.assets-desc',
+ group: 'image',
+ required: true,
+ pattern: '^(?![./]+\\{docName\\})[^\\\\<>?:"|*]{1,}$',
+ options: {
+ patternmessage: '[\\<>?:"|*] are not allowed. Cannot starts with ./{docName}, /{docName} or {docName}.'
+ },
+ },
+ 'assets.path-type': {
+ defaultValue: 'auto',
+ title: 'T_setting-panel.schema.assets.path-type',
+ type: 'string',
+ group: 'image',
+ required: true,
+ enum: ['auto', 'relative', 'absolute'],
+ options: {
+ enum_titles: ['Auto', 'Relative', 'Absolute'],
+ },
+ },
+ 'editor.line-numbers': {
+ defaultValue: 'on',
+ title: 'T_setting-panel.schema.editor.line-numbers',
+ enum: ['on', 'off', 'relative', 'interval'],
+ options: {
+ enum_titles: ['On', 'Off', 'Relative', 'Interval'],
+ },
+ type: 'string',
+ group: 'editor',
+ required: true,
+ },
+ 'auto-save': {
+ defaultValue: 2000,
+ title: 'T_setting-panel.schema.auto-save',
+ enum: [0, 2000, 4000, 8000, 30000, 60000],
+ options: {
+ enum_titles: ['Disable', '2s', '4s', '8s', '30s', '60s'],
+ },
+ type: 'number',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.ordered-list-completion': {
+ defaultValue: 'increase',
+ title: 'T_setting-panel.schema.editor.ordered-list-completion',
+ type: 'string',
+ enum: ['auto', 'increase', 'one', 'off'],
+ options: {
+ enum_titles: ['Auto', '1. ···, 2. ···, 3. ···', '1. ···, 1. ···, 1. ···', 'Off'],
+ },
+ group: 'editor',
+ required: true,
+ },
+ 'editor.font-size': {
+ defaultValue: 16,
+ title: 'T_setting-panel.schema.editor.font-size',
+ type: 'number',
+ format: 'range',
+ minimum: 12,
+ maximum: 40,
+ group: 'editor',
+ },
+ 'editor.tab-size': {
+ defaultValue: 4,
+ title: 'T_setting-panel.schema.editor.tab-size',
+ type: 'number',
+ enum: [2, 4],
+ group: 'editor',
+ required: true,
+ },
+ 'editor.font-family': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.editor.font-family',
+ type: 'string',
+ group: 'editor',
+ options: {
+ inputAttributes: { placeholder: 'e.g., \'Courier New\', monospace' }
+ },
+ },
+ 'editor.font-ligatures': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.editor.font-ligatures',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.mouse-wheel-zoom': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.editor.mouse-wheel-zoom',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.minimap': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.minimap',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.enable-preview': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.enable-preview',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.quick-suggestions': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.editor.quick-suggestions',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.suggest-on-trigger-characters': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.suggest-on-trigger-characters',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.sticky-scroll-enabled': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.sticky-scroll-enabled',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.enable-trigger-suggest-bulb': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.enable-trigger-suggest-bulb',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'editor.enable-ai-copilot-action': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.enable-ai-copilot-action',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ },
+ 'render.md-html': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-html',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-breaks': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-breaks',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-linkify': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-linkify',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-wiki-links': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-wiki-links',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-typographer': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.md-typographer',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-sup': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-sup',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.md-sub': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-sub',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ },
+ 'render.multimd-multiline': {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.multimd-multiline',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ 'render.multimd-rowspan': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.multimd-rowspan',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ 'render.multimd-headerless': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.multimd-headerless',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ 'render.multimd-multibody': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.render.multimd-multibody',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ needReloadWindowWhenChanged: true,
+ },
+ shell: {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.shell',
+ type: 'string',
+ group: 'other',
+ },
+ 'server.host': {
+ defaultValue: '127.0.0.1',
+ title: 'T_setting-panel.schema.server.host',
+ type: 'string',
+ enum: ['127.0.0.1', '0.0.0.0'],
+ group: 'other',
+ required: true,
+ },
+ 'server.port': {
+ defaultValue: 3044,
+ title: 'T_setting-panel.schema.server.port',
+ description: 'T_setting-panel.schema.server.port-desc',
+ type: 'integer',
+ format: 'number',
+ group: 'other',
+ required: true,
+ minimum: 10,
+ maximum: 65535,
+ },
+ 'tree.exclude': {
+ defaultValue: DEFAULT_EXCLUDE_REGEX,
+ title: 'T_setting-panel.schema.tree.exclude',
+ type: 'string',
+ group: 'other',
+ description: 'e.g., ' + DEFAULT_EXCLUDE_REGEX,
+ validator: (_schema, value, path) => {
+ if (value === '') return []
+ try {
+ // eslint-disable-next-line no-new
+ new RegExp(value)
+ return []
+ } catch (e: any) {
+ return [{ property: 'tree.exclude', path, message: e.message }]
+ }
+ }
+ },
+ 'keep-running-after-closing-window': {
+ defaultValue: !isMacOS,
+ title: 'T_setting-panel.schema.keep-running-after-closing-window',
+ type: 'boolean',
+ group: 'other',
+ format: 'checkbox',
+ required: true,
+ },
+ 'hide-main-window-on-startup': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.hide-main-window-on-startup',
+ type: 'boolean',
+ group: 'other',
+ format: 'checkbox',
+ required: true,
+ },
+ envs: {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.envs',
+ type: 'string',
+ group: 'other',
+ format: 'textarea',
+ options: {
+ inputAttributes: { placeholder: 'PATH: /opt/homebrew/bin:/use/local/bin\nGRAPHVIZ_DOT: /opt/homebrew/bin/dot', style: 'height: 4em' }
+ }
+ },
+ 'proxy.enabled': {
+ defaultValue: false,
+ title: 'T_setting-panel.schema.proxy.enabled',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'proxy',
+ },
+ 'proxy.server': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.proxy.server',
+ type: 'string',
+ group: 'proxy',
+ pattern: '^(|.+:\\d{2,5})$',
+ options: {
+ inputAttributes: { placeholder: 'e.g. 127.0.0.1:8080', }
+ }
+ },
+ 'proxy.bypass-list': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.proxy.bypass-list',
+ type: 'string',
+ group: 'proxy',
+ options: {
+ inputAttributes: { placeholder: ';*.google.com;*foo.com;1.2.3.4:5678', }
+ }
+ },
+ 'proxy.pac-url': {
+ defaultValue: '',
+ title: 'T_setting-panel.schema.proxy.pac-url',
+ type: 'string',
+ group: 'proxy',
+ options: {
+ inputAttributes: { placeholder: 'http://', }
+ }
+ },
+ } as Partial as any,
+ required: [],
+ groups: [
+ { label: 'T_setting-panel.tabs.repos', value: 'repos' },
+ { label: 'T_setting-panel.tabs.appearance', value: 'appearance' },
+ { label: 'T_setting-panel.tabs.editor', value: 'editor' },
+ { label: 'T_setting-panel.tabs.render', value: 'render' },
+ { label: 'T_setting-panel.tabs.image', value: 'image' },
+ { label: 'T_setting-panel.tabs.proxy', value: 'proxy' },
+ ]
+})
+
+if (isWindows || FLAG_DISABLE_XTERM) {
+ delete (schema.properties as any).envs
+}
+
+if (FLAG_DISABLE_XTERM) {
+ delete (schema.properties as any).shell
+ delete (schema.properties as any)['server.host']
+ delete (schema.properties as any)['server.port']
+ delete (schema.properties as any)['updater.source']
+}
+
+if (FLAG_MAS) {
+ delete (schema.properties as any)['updater.source']
+}
+
+export function getDefaultSettingSchema (): SettingSchema {
+ return cloneDeep(schema)
+}
diff --git a/src/renderer/plugins.ts b/src/renderer/plugins.ts
new file mode 100644
index 000000000..1b3b56fe7
--- /dev/null
+++ b/src/renderer/plugins.ts
@@ -0,0 +1,161 @@
+import buildInRenderers from '@fe/plugins/build-in-renderers'
+import customStyles from '@fe/plugins/custom-styles'
+import customKeybindings from '@fe/plugins/custom-keybindings'
+import electronZoom from '@fe/plugins/electron-zoom'
+import historyStack from '@fe/plugins/history-stack'
+import fileTreeFunctions from '@fe/plugins/file-tree-functions'
+import statusBarSetting from '@fe/plugins/status-bar-setting'
+import statusBarRepositorySwitch from '@fe/plugins/status-bar-repository-switch'
+import statusBarView from '@fe/plugins/status-bar-view'
+import statusBarNavigation from '@fe/plugins/status-bar-navigation'
+import statusBarInsert from '@fe/plugins/status-bar-insert'
+import statusBarTool from '@fe/plugins/status-bar-tool'
+import statusBarDocumentInfo from '@fe/plugins/status-bar-document-info'
+import statusBarHelp from '@fe/plugins/status-bar-help'
+import statusBarPremium from './plugins/status-bar-premium'
+import statusBarTheme from '@fe/plugins/status-bar-theme'
+import statusBarHistory from '@fe/plugins/status-bar-history'
+import statusBarPresentation from '@fe/plugins/status-bar-presentation'
+import controlCenter from '@fe/plugins/control-center'
+import statusBarTerminal from '@fe/plugins/status-bar-terminal'
+import statusBarExtension from '@fe/plugins/status-bar-extension'
+import statusBarGet from '@fe/plugins/status-bar-get'
+import editorPaste from '@fe/plugins/editor-paste'
+import editorAttachment from '@fe/plugins/editor-attachment'
+import editorMarkdown from '@fe/plugins/editor-markdown'
+import editorMdSyntax from '@fe/plugins/editor-md-syntax'
+import editorMdList from '@fe/plugins/editor-md-list'
+import editorWords from '@fe/plugins/editor-words'
+import editorPathCompletion from '@fe/plugins/editor-path-completion'
+import editorFolding from '@fe/plugins/editor-folding'
+import editorRestoreState from '@fe/plugins/editor-restore-state'
+import copyText from '@fe/plugins/copy-text'
+import switchTodo from '@fe/plugins/switch-todo'
+import imageViewer from '@fe/plugins/image-viewer'
+import mediaPlayer from '@fe/plugins/media-player'
+import emoji from '@fe/plugins/emoji'
+import getStarted from '@fe/plugins/get-started'
+import markdownWikiLinks from '@fe/plugins/markdown-wiki-links'
+import markdownHtml from '@fe/plugins/markdown-html'
+import markdownRenderVnode from '@fe/plugins/markdown-render-vnode'
+import markdownMacro from '@fe/plugins/markdown-macro'
+import markdownFrontMatter from '@fe/plugins/markdown-front-matter'
+import markdownImsize from '@fe/plugins/markdown-imsize'
+import markdownToc from '@fe/plugins/markdown-toc'
+import markdownCodeWrap from '@fe/plugins/markdown-code-wrap'
+import markdownCodeHighlight from '@fe/plugins/markdown-code-highlight'
+import markdownLink from '@fe/plugins/markdown-link'
+import markdownTable from '@fe/plugins/markdown-table'
+import markdownTaskList from '@fe/plugins/markdown-task-list'
+import markdownFootnote from '@fe/plugins/markdown-footnote'
+import markdownKatex from '@fe/plugins/markdown-katex'
+import markdownCodeCopy from '@fe/plugins/markdown-code-copy'
+import markdownCodeRun from '@fe/plugins/markdown-code-run'
+import markdownPlantuml from '@fe/plugins/markdown-plantuml'
+import markdownMindMap from '@fe/plugins/markdown-mind-map'
+import markdownMermaid from '@fe/plugins/markdown-mermaid'
+import markdownApplet from '@fe/plugins/markdown-applet'
+import markdownEcharts from '@fe/plugins/markdown-echarts'
+import markdownDrawio from '@fe/plugins/markdown-drawio'
+import markdownLuckysheet from '@fe/plugins/markdown-luckysheet'
+import markdownContainer from '@fe/plugins/markdown-container'
+import markdownHeadingNumber from '@fe/plugins/markdown-heading-number'
+import markdownGithubAlerts from '@fe/plugins/markdown-github-alerts'
+import markdownMisc from '@fe/plugins/misc'
+import syncScroll from '@fe/plugins/sync-scroll'
+import imageLocalization from '@fe/plugins/image-localization'
+import viewImageContextMenus from '@fe/plugins/view-image-context-menus'
+import imageHostingPicgo from '@fe/plugins/image-hosting-picgo'
+import copyContent from '@fe/plugins/copy-content'
+import sharePreview from '@fe/plugins/share-preview'
+import codeRunners from '@fe/plugins/code-runners'
+import watchFileRefresh from '@fe/plugins/watch-file-refresh'
+import previewFont from '@fe/plugins/preview-font'
+import dropToOpenFile from '@fe/plugins/drop-to-open-file'
+import recordRecentDocument from '@fe/plugins/record-recent-document'
+import aiCopilot from '@fe/plugins/ai-copilot'
+import viewLinks from '@fe/plugins/view-links'
+import insertTable from '@fe/plugins/insert-table'
+import textComparator from '@fe/plugins/text-comparator'
+
+export default [
+ buildInRenderers,
+ customStyles,
+ customKeybindings,
+ electronZoom,
+ historyStack,
+ fileTreeFunctions,
+ statusBarSetting,
+ statusBarRepositorySwitch,
+ statusBarView,
+ statusBarNavigation,
+ statusBarInsert,
+ statusBarTool,
+ statusBarDocumentInfo,
+ statusBarHelp,
+ statusBarPremium,
+ statusBarTheme,
+ statusBarHistory,
+ statusBarTerminal,
+ statusBarExtension,
+ controlCenter,
+ statusBarPresentation,
+ statusBarGet,
+ editorPaste,
+ editorAttachment,
+ editorMarkdown,
+ editorMdSyntax,
+ editorMdList,
+ editorWords,
+ editorPathCompletion,
+ editorFolding,
+ editorRestoreState,
+ copyText,
+ switchTodo,
+ imageViewer,
+ mediaPlayer,
+ emoji,
+ getStarted,
+ markdownWikiLinks,
+ markdownHtml,
+ markdownRenderVnode,
+ markdownMacro,
+ markdownFrontMatter,
+ markdownImsize,
+ markdownToc,
+ markdownCodeWrap,
+ markdownCodeHighlight,
+ markdownLink,
+ markdownTable,
+ markdownTaskList,
+ markdownFootnote,
+ markdownKatex,
+ markdownCodeCopy,
+ markdownCodeRun,
+ markdownPlantuml,
+ markdownMindMap,
+ markdownMermaid,
+ markdownApplet,
+ markdownEcharts,
+ markdownDrawio,
+ markdownLuckysheet,
+ markdownContainer,
+ markdownHeadingNumber,
+ markdownMisc,
+ syncScroll,
+ imageLocalization,
+ viewImageContextMenus,
+ imageHostingPicgo,
+ copyContent,
+ sharePreview,
+ codeRunners,
+ watchFileRefresh,
+ previewFont,
+ dropToOpenFile,
+ recordRecentDocument,
+ markdownGithubAlerts,
+ aiCopilot,
+ viewLinks,
+ insertTable,
+ textComparator,
+]
diff --git a/src/renderer/plugins/ai-copilot.ts b/src/renderer/plugins/ai-copilot.ts
new file mode 100644
index 000000000..276fd107a
--- /dev/null
+++ b/src/renderer/plugins/ai-copilot.ts
@@ -0,0 +1,47 @@
+import { Plugin } from '@fe/context'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+import type { languages } from 'monaco-editor'
+
+export default {
+ name: 'ai-copilot',
+ register: ctx => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ const extensionId = '@yank-note/extension-ai-copilot'
+ const actionId = 'install-ai-copilot-extension'
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
+
+ monaco.languages.registerCodeActionProvider('*', {
+ provideCodeActions (): languages.CodeActionList {
+ const actionTitle = ctx.i18n.t('edit-or-generate-text-using-ai')
+
+ const enabled = ctx.setting.getSetting('editor.enable-ai-copilot-action', true)
+ if (!getInitialized() || checkExtensionLoaded() || !enabled) {
+ return { dispose: () => 0, actions: [] }
+ }
+
+ const actions: languages.CodeAction[] = [{
+ title: actionTitle,
+ command: { id: actionId, title: actionTitle },
+ kind: 'refactor',
+ diagnostics: [],
+ isPreferred: true,
+ }]
+
+ return {
+ dispose: () => 0,
+ actions
+ }
+ },
+
+ async resolveCodeAction (codeAction: languages.CodeAction): Promise {
+ if (codeAction.command?.id === actionId) {
+ ctx.showExtensionManager(extensionId)
+ }
+
+ codeAction.command = undefined
+ return codeAction
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/build-in-renderers.ts b/src/renderer/plugins/build-in-renderers.ts
new file mode 100644
index 000000000..b301573eb
--- /dev/null
+++ b/src/renderer/plugins/build-in-renderers.ts
@@ -0,0 +1,79 @@
+import type { Plugin } from '@fe/context'
+import type { Doc } from '@fe/types'
+
+export default {
+ name: 'build-in-renderers',
+ register: (ctx) => {
+ ctx.renderer.registerRenderer({
+ name: 'not-markdown-file',
+ order: 999999999,
+ when (env) {
+ return !env.file || !ctx.doc.isMarkdownFile(env.file)
+ },
+ render (_, env) {
+ const { h } = ctx.lib.vue
+ return [
+ h('h1', env.file?.name),
+ h('p', [h('em', env.file ? 'Not a markdown file.' : '')])
+ ]
+ },
+ })
+
+ ctx.renderer.registerRenderer({
+ name: 'markdown',
+ order: -255,
+ when (env) {
+ return !!(env.file && ctx.doc.isMarkdownFile(env.file))
+ },
+ render (src, env) {
+ return ctx.markdown.markdown.render(src, env)
+ },
+ })
+
+ ctx.renderer.registerRenderer({
+ name: 'plain-text',
+ when (env) {
+ return !!(env.file && env.file.path.toLowerCase().endsWith('.txt'))
+ },
+ render (src) {
+ return ctx.lib.vue.h('div', {
+ style: {
+ padding: '20px',
+ whiteSpace: 'pre-wrap',
+ wordBreak: 'break-all',
+ },
+ }, src)
+ },
+ })
+
+ function isHtmlDoc (doc: Doc) {
+ return doc.type === 'file' && doc.path.toLowerCase().endsWith('.html')
+ }
+
+ let renderHtmlTime = 0
+ ctx.renderer.registerRenderer({
+ name: 'html',
+ when (env) {
+ return !!(env.file && !env.safeMode && isHtmlDoc(env.file))
+ },
+ render (src, env) {
+ const iframeProps = { style: `background: #fff; position: fixed; left: 0; top: 0; height: var(${ctx.args.CSS_VAR_NAME.PREVIEWER_HEIGHT})` }
+ const doc = env.file
+ if (doc) {
+ const url = ctx.base.getAttachmentURL(doc) + '?_t=' + renderHtmlTime
+ const html = ``
+ return ctx.lib.vue.h(ctx.embed.IFrame, { html, triggerParentKeyBoardEvent: true, iframeProps })
+ } else {
+ return ctx.lib.vue.h(ctx.embed.IFrame, { html: src, triggerParentKeyBoardEvent: true, iframeProps })
+ }
+ },
+ })
+
+ ctx.registerHook('DOC_SAVED', ({ doc }) => {
+ if (isHtmlDoc(doc)) { // render html doc after saved
+ renderHtmlTime = Date.now()
+ ctx.view.render()
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/code-runners.tsx b/src/renderer/plugins/code-runners.tsx
new file mode 100644
index 000000000..8684a1e36
--- /dev/null
+++ b/src/renderer/plugins/code-runners.tsx
@@ -0,0 +1,266 @@
+import type { Plugin } from '@fe/context'
+import { sleep } from '@fe/utils'
+import type { CodeRunnerRunOptions } from '@fe/types'
+
+const getConsole = (console: Console, resolve: (value: string) => void) => {
+ const stringify = (args: any[]) => args.map((arg) => {
+ if (['boolean', 'number', 'bigint', 'string', 'symbol', 'function'].includes(typeof arg)) {
+ return arg.toString()
+ } else {
+ return JSON.stringify(arg)
+ }
+ }).join(' ')
+
+ const tick = async (args: any[]) => {
+ const str = stringify(args) + '\n'
+ resolve(str)
+ }
+
+ return new Proxy(console, {
+ get: (obj: any, prop: any) => ['error', 'warn', 'info', 'log', 'debug'].includes(prop)
+ ? (...args: any[]) => {
+ // obj[prop](...args)
+ if (prop === 'log') {
+ tick(args)
+ } else {
+ tick([`${prop[0]}:`, ...args])
+ }
+ }
+ : obj[prop]
+ })
+}
+
+let javascriptWorker: Worker | null = null
+
+class JavascriptIframeExecutor {
+ private _code: string
+ private _signal: AbortSignal
+ private _outputType: 'plain' | 'html'
+ private _flush: CodeRunnerRunOptions['flusher']
+
+ constructor (code: string, outputHtml: boolean, opts: CodeRunnerRunOptions) {
+ this._code = code
+ this._signal = opts.signal
+ this._flush = opts.flusher
+ this._outputType = outputHtml ? 'html' : 'plain'
+ }
+
+ private _getIframe () {
+ const id = 'code-runner-javascript-vm'
+
+ // clean up
+ document.getElementById(id)?.remove()
+
+ const iframe = document.createElement('iframe')
+ iframe.id = id
+ iframe.style.display = 'none'
+ document.body.appendChild(iframe)
+
+ const iframeWindow = iframe.contentWindow! as Window & typeof globalThis
+ iframeWindow.ctx = window.ctx
+
+ return iframe
+ }
+
+ public async run () {
+ await sleep(0)
+ const iframe = this._getIframe()
+ const iframeWindow = iframe.contentWindow! as Window & typeof globalThis
+
+ const closed = new Promise(resolve => {
+ this._signal.addEventListener('abort', () => {
+ iframe.remove()
+ resolve()
+ })
+ })
+
+ const xConsole = getConsole(
+ iframeWindow.console,
+ val => this._flush(this._outputType, val),
+ )
+
+ const AsyncFunction = iframeWindow.eval('(async function(){}).constructor')
+ const fn = new AsyncFunction('console', 'ctx', this._code)
+
+ await sleep(0)
+ await fn.call(iframeWindow, xConsole, window.ctx)
+ await sleep(0)
+ this._flush(this._outputType, '')
+
+ await closed
+
+ return null
+ }
+}
+
+class JavascriptWorkerExecutor {
+ private _code: string
+ private _signal: AbortSignal
+ private _flush: CodeRunnerRunOptions['flusher']
+ private _outputType: 'plain' | 'html'
+
+ private _workerScript = `
+ const getConsole = ${getConsole.toString()}
+ self.onmessage = async (event) => {
+ const { code, isb } = event.data
+
+ const maxBuffer = 8 * 1024
+ const maxFlushInterval = 100
+
+ let buffer = ''
+
+ const flushBuffer = () => {
+ if (buffer) {
+ Atomics.wait(isb, 0, 1)
+ self.postMessage({ type: 'output', value: buffer })
+ buffer = ''
+ }
+ }
+
+ const flush = (type, val) => {
+ if (type === 'output') {
+ buffer += val
+
+ if (buffer.length > maxBuffer) {
+ flushBuffer()
+ }
+ } else {
+ flushBuffer()
+ Atomics.wait(isb, 0, 1)
+ self.postMessage({ type, value: val })
+ }
+ }
+
+ setInterval(flushBuffer, 100)
+
+ const xConsole = getConsole(console, val => flush('output', val))
+ const AsyncFunction = eval('(async function(){}).constructor')
+
+ try {
+ const fn = new AsyncFunction('console', code)
+ await fn.call(self, xConsole)
+ flush('done', '')
+ } catch (error) {
+ flush('error', error.message || String(error))
+ }
+ }
+ `
+
+ constructor (code: string, outputHtml: boolean, opts: CodeRunnerRunOptions) {
+ this._code = code
+ this._signal = opts.signal
+ this._flush = opts.flusher
+ this._outputType = outputHtml ? 'html' : 'plain'
+ }
+
+ private _getWorker () {
+ if (javascriptWorker) {
+ javascriptWorker.terminate()
+ javascriptWorker = null
+ }
+
+ const blob = new Blob([this._workerScript], { type: 'application/javascript' })
+ const url = URL.createObjectURL(blob)
+ javascriptWorker = new Worker(url)
+ URL.revokeObjectURL(url)
+
+ return javascriptWorker
+ }
+
+ public async run () {
+ await sleep(0)
+ await new Promise(resolve => {
+ const isb = new Int32Array(new SharedArrayBuffer(4))
+
+ const _flush = (value: string) => {
+ Atomics.store(isb, 0, 1)
+ Atomics.notify(isb, 0)
+ this._flush(this._outputType, value)
+ Atomics.store(isb, 0, 0)
+ Atomics.notify(isb, 0)
+ }
+
+ const worker = this._getWorker()
+ worker.onmessage = async (event) => {
+ const { type, value } = event.data
+ if (type === 'output') {
+ _flush(value)
+ } else if (type === 'error') {
+ _flush(value)
+ } else if (type === 'done') {
+ _flush('')
+ }
+ }
+
+ worker.postMessage({ code: this._code, isb })
+
+ this._signal.addEventListener('abort', () => {
+ worker.terminate()
+ resolve()
+ })
+ })
+
+ return null
+ }
+}
+
+export default {
+ name: 'code-runners',
+ register: (ctx) => {
+ ctx.runner.registerRunner({
+ name: 'javascript',
+ order: 100,
+ nonInterruptible: true,
+ match (language) {
+ return ['js', 'javascript'].includes(language.toLowerCase())
+ },
+ getTerminalCmd () {
+ return null
+ },
+ async run (_, code, opts) {
+ const firstLine = code.split('\n')[0].trim()
+ const noWorker = firstLine.includes('--no-worker--')
+ const outputHtml = firstLine.includes('--output-html--')
+ return noWorker
+ ? new JavascriptIframeExecutor(code, outputHtml, opts).run()
+ : new JavascriptWorkerExecutor(code, outputHtml, opts).run()
+ },
+ })
+
+ ctx.runner.registerRunner({
+ name: '_scripts',
+ order: 255,
+ match (language) {
+ return [
+ 'sh', 'shell',
+ 'bash', 'php',
+ 'python', 'py',
+ 'node', 'bat',
+ ].includes(language.toLowerCase())
+ },
+ getTerminalCmd () {
+ return null
+ },
+ async run () {
+ const extensionId = '@yank-note/extension-code-runner'
+ return {
+ type: 'html',
+ value: `${
+ ctx.i18n.t('install-extension-tips', 'Code Runner')
+ }`
+ }
+ },
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` Run Code (JavaScript)', insertText: '```js\n// --run--\n${1:await new Promise(r => setTimeout(r, 500))\nconsole.log("hello world!")}\n```\n', block: true },
+ { language: 'markdown', label: '/ ``` Run Code (JavaScript - No Worker)', insertText: '```js\n// --run-- --no-worker--\n${1:await new Promise(r => setTimeout(r, 500))\nctx.ui.useToast().show("info", "HELLOWORLD!")\nconsole.log("hello world!")}\n```\n', block: true },
+ { language: 'markdown', label: '/ ``` Run Code (Bash)', insertText: '```bash\n# --run--\n${1:echo HELLOWORLD}\n```\n', block: true },
+ { language: 'markdown', label: '/ ``` Run Code (C)', insertText: '```c\n// --run-- gcc \\$tmpFile.c -o \\$tmpFile.out && \\$tmpFile.out\n${1:#include \n \nint main () {\n printf("Hello, World!");\n return 0;\n}}\n```\n', block: true },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/control-center.ts b/src/renderer/plugins/control-center.ts
new file mode 100644
index 000000000..8b77a2772
--- /dev/null
+++ b/src/renderer/plugins/control-center.ts
@@ -0,0 +1,117 @@
+import { Plugin } from '@fe/context'
+import type { Components } from '@fe/types'
+
+export default {
+ name: 'status-control-center',
+ register: ctx => {
+ function buildMenuList (): Components.ControlCenter.Item[] {
+ return [
+ {
+ type: 'btn',
+ icon: 'side-bar',
+ title: ctx.i18n.t('control-center.switch.side-bar', ctx.keybinding.getKeysLabel('layout.toggle-side')),
+ checked: ctx.store.state.showSide,
+ onClick: () => {
+ ctx.layout.toggleSide()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'edit-solid',
+ title: ctx.i18n.t('control-center.switch.editor', ctx.keybinding.getKeysLabel('layout.toggle-editor')),
+ checked: ctx.store.state.showEditor,
+ onClick: () => {
+ ctx.layout.toggleEditor()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'eye-regular',
+ title: ctx.i18n.t('control-center.switch.view', ctx.keybinding.getKeysLabel('layout.toggle-view')),
+ checked: ctx.store.state.showView,
+ onClick: () => {
+ ctx.layout.toggleView()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'columns-solid',
+ title: ctx.i18n.t('control-center.switch.sync-scroll'),
+ checked: ctx.store.state.syncScroll,
+ onClick: () => {
+ ctx.view.toggleSyncScroll()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'paint-roller',
+ title: ctx.i18n.t('control-center.switch.sync-rendering'),
+ checked: ctx.store.state.autoPreview,
+ onClick: () => {
+ ctx.view.toggleAutoPreview()
+ if (ctx.store.state.autoPreview) {
+ ctx.view.refresh()
+ }
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'text-width-solid',
+ title: ctx.i18n.t('control-center.switch.word-wrap', ctx.keybinding.getKeysLabel('editor.toggle-wrap')),
+ checked: ctx.store.state.wordWrap === 'on',
+ onClick: () => {
+ ctx.editor.toggleWrap()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'keyboard-solid',
+ title: ctx.i18n.t('control-center.switch.typewriter-mode'),
+ checked: ctx.store.state.typewriterMode,
+ onClick: () => {
+ ctx.editor.toggleTypewriterMode()
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'search-solid',
+ title: ctx.i18n.t('control-center.switch.find-in-preview', ctx.keybinding.getKeysLabel('view.show-find-in-preview')),
+ hidden: !ctx.store.state.showView || ctx.store.state.previewer !== 'default',
+ onClick: () => {
+ ctx.action.getActionHandler('view.show-find-in-preview')()
+ }
+ },
+ ]
+ }
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.switch.items.push(...buildMenuList())
+ })
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.navigation.items.push(
+ {
+ type: 'btn',
+ icon: 'sync-alt-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.refresh', ctx.keybinding.getKeysLabel('view.refresh')),
+ onClick: () => {
+ ctx.view.refresh()
+ ctx.workbench.ControlCenter.toggle(false)
+ }
+ },
+ {
+ type: 'btn',
+ icon: 'bolt-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.goto', ctx.keybinding.getKeysLabel('workbench.show-quick-open')),
+ showInActionBar: true,
+ onClick: () => {
+ ctx.action.getActionHandler('workbench.show-quick-open')()
+ ctx.workbench.ControlCenter.toggle(false)
+ }
+ },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/copy-content.tsx b/src/renderer/plugins/copy-content.tsx
new file mode 100644
index 000000000..37bfc0e67
--- /dev/null
+++ b/src/renderer/plugins/copy-content.tsx
@@ -0,0 +1,194 @@
+import type { Plugin } from '@fe/context'
+import type Token from 'markdown-it/lib/token'
+
+export default {
+ name: 'copy-content',
+ register: (ctx) => {
+ const options = ctx.lib.vue.reactive({
+ type: 'rt' as 'html' | 'rt' | 'markdown',
+ inlineLocalImage: false,
+ uploadLocalImage: false,
+ inlineStyle: true,
+ highlightCode: true,
+ })
+
+ const selectionLength = ctx.lib.vue.ref(0)
+
+ const panel = ctx.lib.vue.defineComponent({
+ setup () {
+ ctx.lib.vue.watch(() => ({ ...options }), (val, prev) => {
+ if (val.uploadLocalImage && val.inlineLocalImage) {
+ if (!prev.uploadLocalImage) {
+ options.inlineLocalImage = false
+ } else {
+ options.uploadLocalImage = false
+ }
+ }
+ })
+
+ return () =>
+
+function getCode (monaco: typeof Monaco, key: string): number {
+ if (!cachedMap) {
+ cachedMap = {
+ 'ctrl': isMacOS ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd,
+ 'control': isMacOS ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd,
+ 'shift': monaco.KeyMod.Shift,
+ 'alt': monaco.KeyMod.Alt,
+ 'meta': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'cmd': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'command': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'win': isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl,
+ 'backspace': monaco.KeyCode.Backspace,
+ 'tab': monaco.KeyCode.Tab,
+ 'enter': monaco.KeyCode.Enter,
+ 'pause': monaco.KeyCode.PauseBreak,
+ 'capslock': monaco.KeyCode.CapsLock,
+ 'esc': monaco.KeyCode.Escape,
+ 'space': monaco.KeyCode.Space,
+ 'pageup': monaco.KeyCode.PageUp,
+ 'pagedown': monaco.KeyCode.PageDown,
+ 'end': monaco.KeyCode.End,
+ 'home': monaco.KeyCode.Home,
+ 'left': monaco.KeyCode.LeftArrow,
+ 'up': monaco.KeyCode.UpArrow,
+ 'right': monaco.KeyCode.RightArrow,
+ 'down': monaco.KeyCode.DownArrow,
+ 'arrowleft': monaco.KeyCode.LeftArrow,
+ 'arrowup': monaco.KeyCode.UpArrow,
+ 'arrowright': monaco.KeyCode.RightArrow,
+ 'arrowdown': monaco.KeyCode.DownArrow,
+ 'insert': monaco.KeyCode.Insert,
+ 'delete': monaco.KeyCode.Delete,
+ '0': monaco.KeyCode.Digit0,
+ '1': monaco.KeyCode.Digit1,
+ '2': monaco.KeyCode.Digit2,
+ '3': monaco.KeyCode.Digit3,
+ '4': monaco.KeyCode.Digit4,
+ '5': monaco.KeyCode.Digit5,
+ '6': monaco.KeyCode.Digit6,
+ '7': monaco.KeyCode.Digit7,
+ '8': monaco.KeyCode.Digit8,
+ '9': monaco.KeyCode.Digit9,
+ 'a': monaco.KeyCode.KeyA,
+ 'b': monaco.KeyCode.KeyB,
+ 'c': monaco.KeyCode.KeyC,
+ 'd': monaco.KeyCode.KeyD,
+ 'e': monaco.KeyCode.KeyE,
+ 'f': monaco.KeyCode.KeyF,
+ 'g': monaco.KeyCode.KeyG,
+ 'h': monaco.KeyCode.KeyH,
+ 'i': monaco.KeyCode.KeyI,
+ 'j': monaco.KeyCode.KeyJ,
+ 'k': monaco.KeyCode.KeyK,
+ 'l': monaco.KeyCode.KeyL,
+ 'm': monaco.KeyCode.KeyM,
+ 'n': monaco.KeyCode.KeyN,
+ 'o': monaco.KeyCode.KeyO,
+ 'p': monaco.KeyCode.KeyP,
+ 'q': monaco.KeyCode.KeyQ,
+ 'r': monaco.KeyCode.KeyR,
+ 's': monaco.KeyCode.KeyS,
+ 't': monaco.KeyCode.KeyT,
+ 'u': monaco.KeyCode.KeyU,
+ 'v': monaco.KeyCode.KeyV,
+ 'w': monaco.KeyCode.KeyW,
+ 'x': monaco.KeyCode.KeyX,
+ 'y': monaco.KeyCode.KeyY,
+ 'z': monaco.KeyCode.KeyZ,
+ 'contextmenu': monaco.KeyCode.ContextMenu,
+ 'f1': monaco.KeyCode.F1,
+ 'f2': monaco.KeyCode.F2,
+ 'f3': monaco.KeyCode.F3,
+ 'f4': monaco.KeyCode.F4,
+ 'f5': monaco.KeyCode.F5,
+ 'f6': monaco.KeyCode.F6,
+ 'f7': monaco.KeyCode.F7,
+ 'f8': monaco.KeyCode.F8,
+ 'f9': monaco.KeyCode.F9,
+ 'f10': monaco.KeyCode.F10,
+ 'f11': monaco.KeyCode.F11,
+ 'f12': monaco.KeyCode.F12,
+ 'f13': monaco.KeyCode.F13,
+ 'f14': monaco.KeyCode.F14,
+ 'f15': monaco.KeyCode.F15,
+ 'f16': monaco.KeyCode.F16,
+ 'f17': monaco.KeyCode.F17,
+ 'f18': monaco.KeyCode.F18,
+ 'f19': monaco.KeyCode.F19,
+ 'f20': monaco.KeyCode.F20,
+ 'f21': monaco.KeyCode.F21,
+ 'f22': monaco.KeyCode.F22,
+ 'f23': monaco.KeyCode.F23,
+ 'f24': monaco.KeyCode.F24,
+ 'numlock': monaco.KeyCode.NumLock,
+ 'scrolllock': monaco.KeyCode.ScrollLock,
+ ';': monaco.KeyCode.Semicolon,
+ '=': monaco.KeyCode.Equal,
+ ',': monaco.KeyCode.Comma,
+ '-': monaco.KeyCode.Minus,
+ '.': monaco.KeyCode.Period,
+ '/': monaco.KeyCode.Slash,
+ '`': monaco.KeyCode.Backquote,
+ '[': monaco.KeyCode.BracketLeft,
+ '\\': monaco.KeyCode.Backslash,
+ ']': monaco.KeyCode.BracketRight,
+ '\'': monaco.KeyCode.Quote,
+ 'oem_8': monaco.KeyCode.OEM_8,
+ 'intlbackslash': monaco.KeyCode.IntlBackslash,
+ 'numpad0': monaco.KeyCode.Numpad0,
+ 'numpad1': monaco.KeyCode.Numpad1,
+ 'numpad2': monaco.KeyCode.Numpad2,
+ 'numpad3': monaco.KeyCode.Numpad3,
+ 'numpad4': monaco.KeyCode.Numpad4,
+ 'numpad5': monaco.KeyCode.Numpad5,
+ 'numpad6': monaco.KeyCode.Numpad6,
+ 'numpad7': monaco.KeyCode.Numpad7,
+ 'numpad8': monaco.KeyCode.Numpad8,
+ 'numpad9': monaco.KeyCode.Numpad9,
+ 'numpadmultiply': monaco.KeyCode.NumpadMultiply,
+ 'numpadadd': monaco.KeyCode.NumpadAdd,
+ 'numpadsubtract': monaco.KeyCode.NumpadSubtract,
+ 'numpaddecimal': monaco.KeyCode.NumpadDecimal,
+ 'numpaddivide': monaco.KeyCode.NumpadDivide,
+ }
+ }
+
+ return cachedMap[key.trim().toLowerCase()]
+}
+
+function resolveKeys (monaco: typeof Monaco, keys: string | null): number {
+ if (!keys) {
+ return 0
+ }
+
+ let result = 0
+ const keyNames = keys.split('+')
+
+ for (const keyName of keyNames) {
+ const code = getCode(monaco, keyName)
+ if (!code) {
+ return 0
+ }
+
+ if (result) {
+ result |= code
+ } else {
+ result = code
+ }
+ }
+
+ return result
+}
+
+type Chord = {
+ altKey: boolean
+ ctrlKey: boolean
+ keyCode: number
+ metaKey: boolean
+ shiftKey: boolean
+}
+
+function encodeMonacoChord (monaco: typeof Monaco, chord: Chord): number {
+ const { altKey, ctrlKey, keyCode, metaKey, shiftKey } = chord
+ let result = 0
+
+ altKey && (result |= monaco.KeyMod.Alt)
+ ctrlKey && (result |= (isMacOS ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd))
+ metaKey && (result |= (isMacOS ? monaco.KeyMod.CtrlCmd : monaco.KeyMod.WinCtrl))
+ shiftKey && (result |= monaco.KeyMod.Shift)
+
+ return result | keyCode
+}
+
+function encodeMonacoChords (monaco: typeof Monaco, chords: Chord[]): number {
+ if (!chords.length) {
+ return 0
+ }
+
+ const [first, second] = chords
+
+ if (!second) {
+ return encodeMonacoChord(monaco, first)
+ }
+
+ return monaco.KeyMod.chord(
+ encodeMonacoChord(monaco, first),
+ encodeMonacoChord(monaco, second)
+ )
+}
+
+export default {
+ name: 'custom-keybindings',
+ register: (ctx) => {
+ let disposable: Monaco.IDisposable | null = null
+
+ function updateEditorKeybindings () {
+ try {
+ const monaco = ctx.editor.getMonaco()
+ const editor = ctx.editor.getEditor()
+ const service = (editor as any)._standaloneKeybindingService
+
+ disposable?.dispose()
+ disposable = null
+
+ const keybindings = ctx.setting.getSetting('keybindings', []).filter(x => x.type === 'editor')
+ const newKeybindings: Parameters[0] = []
+
+ for (const keybinding of keybindings) {
+ // get original keybinding, for get when condition
+ const originalKeybinding = service._getResolver().lookupPrimaryKeybinding(keybinding.command, service._contextKeyService)
+ let when: string | undefined
+ if (originalKeybinding) {
+ // get when condition expression
+ when = originalKeybinding.when?.serialize()
+ const originMonacoKeys = encodeMonacoChords(monaco, originalKeybinding.resolvedKeybinding._chords)
+ // remove original keybinding
+ newKeybindings.push({ keybinding: originMonacoKeys, command: `-${keybinding.command}`, when })
+ }
+
+ const monacoKeys = resolveKeys(monaco, keybinding.keys)
+
+ if (!monacoKeys && keybinding.keys) {
+ logger.warn('updateEditorKeybindings', `invalid keybinding ${keybinding.keys} for command ${keybinding.command}`)
+ }
+
+ if (monacoKeys) {
+ // new keybinding
+ newKeybindings.push({ keybinding: monacoKeys, command: keybinding.command, when })
+ }
+ }
+
+ logger.debug('updateEditorKeybindings', newKeybindings)
+
+ if (newKeybindings.length) {
+ disposable = monaco.editor.addKeybindingRules(newKeybindings)
+ }
+ } catch (error) {
+ console.error(error)
+ ctx.ui.useToast().show('warning', 'Failed to update editor keybindings')
+ }
+ }
+
+ ctx.action.tapAction(action => {
+ const keybindings = ctx.lib.lodash.keyBy(
+ ctx.setting.getSetting('keybindings', []).filter(x => x.type === 'workbench'),
+ 'command'
+ )
+
+ if (keybindings[action.name]) {
+ action.keys = keybindings[action.name].keys?.split('+') || []
+ }
+ })
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys }) => {
+ if (changedKeys.includes('keybindings')) {
+ ctx.triggerHook('COMMAND_KEYBINDING_CHANGED')
+ updateEditorKeybindings()
+ }
+ })
+
+ ctx.editor.whenEditorReady().then(() => {
+ updateEditorKeybindings()
+
+ // recheck keybindings, for conflict with other keybindings
+ setTimeout(updateEditorKeybindings, 2000)
+ setTimeout(updateEditorKeybindings, 5000)
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/custom-styles.ts b/src/renderer/plugins/custom-styles.ts
new file mode 100644
index 000000000..fa2b031a5
--- /dev/null
+++ b/src/renderer/plugins/custom-styles.ts
@@ -0,0 +1,52 @@
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'custom-styles',
+ register: (ctx) => {
+ ctx.registerHook('STARTUP', () => {
+ const head = document.getElementsByTagName('head')[0]
+ const cssLink = document.createElement('link')
+ cssLink.id = 'custom-css'
+ cssLink.rel = 'stylesheet'
+ cssLink.type = 'text/css'
+ cssLink.href = ctx.args.FLAG_DEMO ? '/github.css' : '/custom-css'
+
+ head.appendChild(cssLink)
+
+ // for demo
+ if (ctx.args.FLAG_DEMO) {
+ ctx.view.addStyleLink('/github.css')
+ }
+ })
+
+ if (ctx.args.FLAG_DEMO) {
+ return
+ }
+
+ ctx.registerHook('SETTING_PANEL_BEFORE_SHOW', async () => {
+ const customStyles = await ctx.api.fetchCustomStyles().catch(() => [])
+ ctx.theme.removeThemeStyle(item => item.from === 'custom')
+ customStyles.forEach(css => {
+ ctx.theme.registerThemeStyle({ from: 'custom', name: css, css })
+ })
+
+ const styles = ctx.theme.getThemeStyles()
+
+ ctx.setting.changeSchema((schema) => {
+ schema.properties['custom-css'].enum = styles.map(x => x.css)
+ schema.properties['custom-css'].options.enum_titles = styles.map(x => x.name)
+ })
+ })
+
+ ctx.registerHook('SETTING_CHANGED', async ({ changedKeys }) => {
+ if (changedKeys.includes('custom-css')) {
+ if (await ctx.ui.useModal().confirm({
+ title: ctx.i18n.t('custom-css.change-confirm.title'),
+ content: ctx.i18n.t('custom-css.change-confirm.content')
+ })) {
+ ctx.base.reloadMainWindow()
+ }
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/drop-to-open-file.ts b/src/renderer/plugins/drop-to-open-file.ts
new file mode 100644
index 000000000..054c73f4d
--- /dev/null
+++ b/src/renderer/plugins/drop-to-open-file.ts
@@ -0,0 +1,89 @@
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'drop-to-open-file',
+ register: (ctx) => {
+ // only support electron
+ if (!ctx.env.isElectron) {
+ return
+ }
+
+ const dragClassName = 'drop-file-dragover-mask'
+ const rightSelector = 'body > #app > .layout .main > .right'
+ let isDrag = true
+
+ function getRightDom () {
+ return document.body.querySelector(rightSelector)
+ }
+
+ function isDragFile (e: DragEvent): boolean {
+ const hasFile = !!e.dataTransfer?.items &&
+ e.dataTransfer.items.length > 0 &&
+ e.dataTransfer.items[0].kind === 'file'
+
+ // only handle drag to right section
+ return hasFile && (e.target as HTMLElement).closest(rightSelector) === getRightDom()
+ }
+
+ function enableDropStyle (e: DragEvent) {
+ if (isDragFile(e)) {
+ isDrag = true
+ e.stopPropagation()
+ e.preventDefault()
+ getRightDom()?.classList.add(dragClassName)
+ }
+ }
+
+ function onDrop (e: DragEvent) {
+ disableDropStyle()
+
+ if (isDragFile(e)) {
+ const item = e.dataTransfer?.items?.[0]
+ // if drag image file, do nothing. let editor handle it
+ if (item && !item.type.toLowerCase().startsWith('image')) {
+ const path = item?.getAsFile()?.path
+ if (path) {
+ e.stopPropagation()
+ e.preventDefault()
+ ctx.doc.switchDocByPath(path)
+ }
+ }
+ }
+ }
+
+ async function disableDropStyle () {
+ isDrag = false
+ await ctx.utils.sleep(50)
+ if (!isDrag) {
+ getRightDom()?.classList.remove(dragClassName)
+ }
+ }
+
+ function listenEvent (win: Window) {
+ win.addEventListener('dragover', enableDropStyle, true)
+ win.addEventListener('dragenter', enableDropStyle, true)
+ win.addEventListener('dragend', disableDropStyle, true)
+ win.addEventListener('dragleave', disableDropStyle, true)
+ win.addEventListener('drop', onDrop, true)
+ }
+
+ listenEvent(window)
+ ctx.view.getRenderIframe().then((iframe) => {
+ listenEvent(iframe.contentWindow!)
+ })
+
+ ctx.theme.addStyles(`
+ .${dragClassName}::after {
+ content: '';
+ position: absolute;
+ pointer-events: none;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background: rgba(0, 0, 0, 0.2);
+ z-index: 210000000;
+ }
+ `)
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-attachment.ts b/src/renderer/plugins/editor-attachment.ts
index bcc2a1c5f..d9cecb66f 100644
--- a/src/renderer/plugins/editor-attachment.ts
+++ b/src/renderer/plugins/editor-attachment.ts
@@ -1,43 +1,67 @@
import dayjs from 'dayjs'
-import { insert, whenEditorReady } from '@fe/context/editor'
-import type { Plugin } from '@fe/context/plugin'
-import * as api from '@fe/support/api'
+import { insert, whenEditorReady } from '@fe/services/editor'
+import type { Plugin } from '@fe/context'
+import type { Doc } from '@fe/types'
+import { encodeMarkdownLink, escapeMd } from '@fe/utils'
+import { basename, dirname, isBelongTo, join, normalizeSep, relative } from '@fe/utils/path'
import store from '@fe/support/store'
-import { encodeMarkdownLink } from '@fe/utils'
-import { Doc } from '@fe/support/types'
-import { dirname, isBelongTo, join, relative } from '@fe/utils/path'
-import { getAction } from '@fe/context/action'
+import * as api from '@fe/support/api'
+import { refreshTree } from '@fe/services/tree'
+import { upload } from '@fe/services/base'
+import { isSameRepo } from '@fe/services/document'
+import { useToast } from '@fe/support/ui/toast'
+import { DOM_CLASS_NAME } from '@fe/support/args'
+import { t } from '@fe/services/i18n'
async function uploadFile (file: any, asImage: boolean) {
if (!store.state.currentFile) {
- throw new Error('当前未打开文件')
+ throw new Error('No file opened.')
}
- const { repo, path } = store.state.currentFile
- const filename = asImage ? null : `${dayjs().format('YYYYMMDDHHmmss')}.${file.name}`
- const { relativePath } = await api.upload(repo, path, file, filename)
+ const filename = file.name
+ const assetPath = await upload(file, store.state.currentFile, filename)
if (asImage) {
- insert(`})`)
+ insert(`})\n`)
} else {
- insert(`附件 [${dayjs().format('YYYY-MM-DD HH:mm')}] [${file.name} (${(file.size / 1024).toFixed(2)}KiB)](${encodeMarkdownLink(relativePath)}){class=open target=_blank}\n`)
+ insert(`[${dayjs().format('YYYY-MM-DD HH:mm')}] [${escapeMd(file.name)} (${(file.size / 1024).toFixed(2)}KiB)](${encodeMarkdownLink(assetPath)}){.${DOM_CLASS_NAME.MARK_OPEN}}\n`)
}
+
+ refreshTree()
}
function addAttachment (asImage = false) {
const input = window.document.createElement('input')
input.type = 'file'
- input.onchange = () => {
+ input.multiple = true
+ input.onchange = async () => {
for (let i = 0; i < input.files!.length; i++) {
- uploadFile(input.files![i], asImage)
+ await uploadFile(input.files![i], asImage)
}
}
input.click()
}
-function addDocument (doc: Doc) {
+async function linkFile () {
+ const { filePaths } = await api.choosePath({ properties: ['openFile', 'multiSelections'] })
+ const useList = filePaths.length > 1
+ for (let path of filePaths) {
+ path = normalizeSep(path)
+ const filename = basename(path)
+ insert(`${useList ? '- ' : ''}[${escapeMd(filename)}](file://${encodeMarkdownLink(path)})\n`)
+ }
+}
+
+function addDocument (doc?: Doc | null) {
+ if (!doc) return
+
const file = store.state.currentFile
if (file) {
+ if (!isSameRepo(file, doc)) {
+ useToast().show('warning', t('insert-different-repo-doc'))
+ return
+ }
+
const cwd = dirname(file.path)
const filePath = isBelongTo(cwd, doc.path)
? relative(cwd, doc.path)
@@ -45,43 +69,93 @@ function addDocument (doc: Doc) {
const fileName = doc.name.replace(/\.[^.]*$/, '')
insert(`[${fileName}](${encodeMarkdownLink(filePath)})`)
} else {
- throw new Error('当前未打开文件')
+ throw new Error('No file opened.')
}
}
export default {
name: 'editor-attachment',
- register: () => {
+ register: (ctx) => {
+ const idAddImage = 'plugin.editor.add-image'
+ const idAddFile = 'plugin.editor.add-file'
+ const idLinkDoc = 'plugin.editor.link-doc'
+ const idLinkFile = 'plugin.editor.link-file'
+
whenEditorReady().then(({ editor, monaco }) => {
editor.addAction({
- id: 'plugin.editor.add-image',
+ id: idAddImage,
contextMenuGroupId: 'modification',
- label: '上传图片',
+ label: t('add-image'),
keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_I
+ monaco.KeyMod.Alt | monaco.KeyCode.KeyI
],
run: () => addAttachment(true),
})
editor.addAction({
- id: 'plugin.editor.add-file',
+ id: idAddFile,
contextMenuGroupId: 'modification',
- label: '插入附件',
+ label: t('editor.context-menu.add-attachment'),
keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_F
+ monaco.KeyMod.Alt | monaco.KeyCode.KeyF
],
run: () => addAttachment(false),
})
editor.addAction({
- id: 'plugin.editor.add-document',
+ id: idLinkDoc,
contextMenuGroupId: 'modification',
- label: '插入文档',
+ label: t('editor.context-menu.link-doc'),
keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_I
+ monaco.KeyMod.Alt | monaco.KeyCode.KeyD
],
- run: () => {
- getAction('filter.choose-document')().then(addDocument)
- },
+ run: () => ctx.routines.chooseDocument().then(addDocument),
})
+ editor.addAction({
+ id: idLinkFile,
+ contextMenuGroupId: 'modification',
+ label: t('editor.context-menu.link-file'),
+ keybindings: [
+ monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.KeyF
+ ],
+ run: () => linkFile(),
+ })
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push(
+ {
+ id: idAddImage,
+ type: 'normal',
+ title: ctx.i18n.t('add-image'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idAddImage) || []),
+ ellipsis: true,
+ onClick: () => addAttachment(true),
+ },
+ {
+ id: idAddFile,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.add-attachment'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idAddFile) || []),
+ ellipsis: true,
+ onClick: () => addAttachment(false),
+ },
+ {
+ id: idLinkDoc,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.link-doc'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idLinkDoc) || []),
+ ellipsis: true,
+ onClick: () => ctx.routines.chooseDocument().then(addDocument),
+ },
+ {
+ id: idLinkFile,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.link-file'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idLinkFile) || []),
+ ellipsis: true,
+ onClick: () => linkFile(),
+ },
+ { type: 'separator' },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/editor-folding.ts b/src/renderer/plugins/editor-folding.ts
new file mode 100644
index 000000000..94b048501
--- /dev/null
+++ b/src/renderer/plugins/editor-folding.ts
@@ -0,0 +1,168 @@
+import type * as Monaco from 'monaco-editor'
+import { IndentRangeProvider } from '@fe/others/monaco-indent-range-provider.js'
+import type { Ctx, Plugin } from '@fe/context'
+import type Token from 'markdown-it/lib/token'
+import { DOM_ATTR_NAME } from '@fe/support/args'
+
+const lengthLimit = 50000
+const rangeLimit = 5000
+
+type TocEntry = {
+ level: number,
+ start: number,
+ end: number,
+}
+
+export class MdFoldingProvider implements Monaco.languages.FoldingRangeProvider {
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ public async provideFoldingRanges (model: Monaco.editor.ITextModel, _context: Monaco.languages.FoldingContext, cancellationToken: Monaco.CancellationToken, retry = true): Promise {
+ if (model.uri.toString() !== this.ctx.doc.toUri(this.ctx.view.getRenderEnv()?.file)) {
+ if (retry) {
+ await this.ctx.utils.sleep(1000)
+ return await this.provideFoldingRanges(model, _context, cancellationToken, false)
+ }
+
+ return []
+ }
+
+ if (model.getValueLength() > lengthLimit) {
+ return []
+ }
+
+ const foldables = await Promise.all([
+ this.getHeaderFoldingRanges(model),
+ this.getBlockFoldingRanges(model),
+ new IndentRangeProvider(model).compute(cancellationToken).then((ranges: any) => {
+ const length = ranges.length
+ const result: Monaco.languages.FoldingRange[] = []
+ for (let i = 0; i < length; i++) {
+ result.push({
+ start: ranges.getStartLineNumber(i),
+ end: ranges.getEndLineNumber(i),
+ })
+ }
+
+ return result
+ })
+ ])
+ return foldables.flat().slice(0, rangeLimit)
+ }
+
+ private async getHeaderFoldingRanges (model: Monaco.editor.ITextModel): Promise {
+ return (await this.buildToc(model)).map(entry => {
+ let { start, end } = entry
+ start++
+ end++
+ return { start, end }
+ })
+ }
+
+ private getRealLine (token: Token) {
+ if (token.meta.attrs && token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_START] && token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_END]) {
+ return [
+ parseInt(token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_START]) - 1,
+ parseInt(token.meta.attrs[DOM_ATTR_NAME.SOURCE_LINE_END]) - 1,
+ ]
+ }
+
+ return token.map!
+ }
+
+ private async getBlockFoldingRanges (model: Monaco.editor.ITextModel): Promise {
+ const tokens = this.ctx.view.getRenderEnv()?.tokens || []
+ const multiLineListItems = tokens.filter(this.isFoldableToken.bind(this))
+ return multiLineListItems.map(listItem => {
+ const [startLine, endLine] = this.getRealLine(listItem)
+ const start = startLine + 1
+ let end = endLine
+ if (model.getLineContent(end).trim().length === 0 && end >= start + 1) {
+ end = end - 1
+ }
+
+ if (listItem.type.startsWith('container') || listItem.type === 'uml_diagram') {
+ end++
+ }
+
+ return { start, end, kind: this.getFoldingRangeKind(listItem) }
+ })
+ }
+
+ private getFoldingRangeKind (listItem: Token): Monaco.languages.FoldingRangeKind | undefined {
+ return (listItem.type === 'comment' || (listItem.type === 'html_block' && listItem.content.startsWith('\n\n```\n' },
- { name: '``` Drawio', type: 'Drawio 图形', insertText: '```xml\n\n${1:}\n```\n' },
- { name: '[]() Drawio Link', type: 'Drawio 图形链接', insertText: '[${2:链接}]($1){link-type="drawio"}' },
- { name: '[]() Luckysheet Link', type: 'Luckysheet 链接', insertText: '[${2:链接}]($1){link-type="luckysheet"}' },
- { name: '```mermaid Mermaid', type: 'Mermaid 图形', insertText: '```mermaid\ngraph LR\n${1:A[Hard] -->|Text| B(Round)}\n```\n' },
- { name: '@startuml Plantuml', type: 'Plantuml 图形', insertText: '@startuml\n${1:a -> b}\n@enduml\n' },
- ].map(x => ({
- label: { name: x.name, type: x.type },
- kind: monaco.languages.CompletionItemKind.Snippet,
- insertText: x.insertText,
- insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
- range: range
- }))
-}
+import { getEditor, getOneIndent, insert, whenEditorReady } from '@fe/services/editor'
+import type { Plugin } from '@fe/context'
+import { t } from '@fe/services/i18n'
+import type { IMarkdownString } from 'monaco-editor'
export default {
name: 'editor-markdown',
- register: () => {
+ register: (ctx) => {
+ function insertDate () {
+ insert(dayjs().format('YYYY-MM-DD'))
+ }
+
+ function insertTime () {
+ insert(dayjs().format('HH:mm:ss'))
+ }
+
+ function revealLineInPreview () {
+ const line = getEditor().getPosition()?.lineNumber
+ if (line && ctx.doc.isSameFile(ctx.view.getRenderEnv()?.file, ctx.store.state.currentFile)) {
+ ctx.view.highlightLine(line, true, 1000)
+ }
+ }
+
+ function focusEditor () {
+ const line = getEditor().getPosition()?.lineNumber
+ if (line) {
+ ctx.view.disableSyncScrollAwhile(() => {
+ getEditor().revealLineInCenter(line)
+ getEditor().focus()
+ })
+ }
+ }
+
+ const idInsertTime = 'plugin.editor.insert-time'
+ const idInsertDate = 'plugin.editor.insert-date'
+ const idRevealLineInPreview = 'plugin.editor.reveal-line-in-preview'
+ const idForceInsertNewLine = 'plugin.editor.force-insert-new-line'
+ const idForceInsertIndent = 'plugin.editor.force-insert-indent'
+ const idRevealCurrentFileInOS = 'plugin.editor.reveal-current-file-in-os'
+ const idRefreshCurrentDoc = 'plugin.editor.refresh-current-document'
+
whenEditorReady().then(({ editor, monaco }) => {
const KM = monaco.KeyMod
const KC = monaco.KeyCode
editor.addAction({
- id: 'plugin.editor.insert-date',
- label: '插入当前日期',
+ id: idInsertDate,
+ label: t('editor.context-menu.insert-date'),
contextMenuGroupId: 'modification',
keybindings: [
- KM.Shift | KM.Alt | KC.KEY_D
+ KM.Shift | KM.Alt | KC.KeyD
],
- run: () => {
- insert(dayjs().format('YYYY-MM-DD'))
- }
+ run: insertDate
})
editor.addAction({
- id: 'plugin.editor.insert-time',
- label: '插入当前时间',
+ id: idInsertTime,
+ label: t('editor.context-menu.insert-time'),
contextMenuGroupId: 'modification',
keybindings: [
- KM.Shift | KM.Alt | KC.KEY_T
+ KM.Shift | KM.Alt | KC.KeyT
],
- run: () => {
- insert(dayjs().format('HH:mm:ss'))
- }
+ run: insertTime
})
- editor.addCommand(KM.CtrlCmd | KC.Enter, () => {
- insert(editor.getModel()!.getEOL())
+ editor.addAction({
+ id: idRevealLineInPreview,
+ label: t('editor.context-menu.reveal-line-in-preview'),
+ contextMenuGroupId: 'other',
+ keybindings: [KM.Alt | KC.KeyL],
+ run: revealLineInPreview
})
- editor.addCommand(KM.Shift | KC.Enter, () => {
- // getOneIndent 接口被移除了 https://github.com/microsoft/monaco-editor/issues/1565
- const getOneIndent = () => {
- const options = editor.getModel()!.getOptions()
- return options.insertSpaces ? ' '.repeat(options.tabSize) : '\t'
+ editor.addAction({
+ id: idForceInsertNewLine,
+ label: t('editor.context-menu.force-insert-new-line'),
+ contextMenuGroupId: 'modification',
+ keybindings: [KM.Alt | KC.Enter],
+ run: () => {
+ insert(editor.getModel()!.getEOL())
}
-
- insert(getOneIndent())
})
- editor.addCommand(KM.CtrlCmd | KM.Shift | KC.UpArrow, () => {
- editor.getAction('editor.action.moveLinesUpAction').run()
+ editor.addAction({
+ id: idForceInsertIndent,
+ label: t('editor.context-menu.force-insert-indent'),
+ contextMenuGroupId: 'modification',
+ keybindings: [KM.Shift | KC.Enter],
+ run: () => {
+ insert(getOneIndent())
+ }
})
- editor.addCommand(KM.CtrlCmd | KM.Shift | KC.DownArrow, () => {
- editor.getAction('editor.action.moveLinesDownAction').run()
- })
+ monaco.editor.addKeybindingRules([
+ {
+ command: 'editor.action.transformToUppercase',
+ keybinding: KM.chord(KM.CtrlCmd | KC.KeyK, KM.CtrlCmd | KC.KeyU),
+ when: 'editorTextFocus'
+ },
+ {
+ command: 'editor.action.transformToLowercase',
+ keybinding: KM.chord(KM.CtrlCmd | KC.KeyK, KM.CtrlCmd | KC.KeyL),
+ when: 'editorTextFocus'
+ }
+ ])
- editor.addCommand(KM.CtrlCmd | KM.Shift | KC.KEY_D, () => {
- editor.getAction('editor.action.copyLinesDownAction').run()
+ editor.onDidCompositionStart(() => {
+ ctx.store.state.inComposition = true
})
- editor.addCommand(KM.CtrlCmd | KC.KEY_J, () => {
- editor.getAction('editor.action.joinLines').run()
+ editor.onDidCompositionEnd(() => {
+ ctx.store.state.inComposition = false
})
- editor.addCommand(KM.chord(KM.CtrlCmd | KC.KEY_K, KM.CtrlCmd | KC.KEY_U), () => {
- editor.getAction('editor.action.transformToUppercase').run()
+ const messageContribution: any = editor.getContribution('editor.contrib.messageController')
+ editor.onDidAttemptReadOnlyEdit(() => {
+ const currentFile = ctx.store.state.currentFile
+ const cmdRevealCurrentFile = `command:vs.editor.ICodeEditor:1:${idRevealCurrentFileInOS}`
+ const cmdRefreshCurrentDoc = `command:vs.editor.ICodeEditor:1:${idRefreshCurrentDoc}`
+ const message =
+ ctx.args.FLAG_READONLY
+ ? ctx.i18n.t('read-only-mode-desc')
+ : !currentFile
+ ? ctx.i18n.t('file-status.no-file')
+ : currentFile.writeable === false
+ ? {
+ value: ctx.i18n.t('file-readonly-desc', cmdRevealCurrentFile, cmdRefreshCurrentDoc),
+ isTrusted: true,
+ } as IMarkdownString
+ : ctx.i18n.t('can-not-edit-this-file-type')
+ messageContribution.showMessage(message, editor.getPosition())
})
- editor.addCommand(KM.chord(KM.CtrlCmd | KC.KEY_K, KM.CtrlCmd | KC.KEY_L), () => {
- editor.getAction('editor.action.transformToLowercase').run()
+ editor.addAction({
+ id: idRevealCurrentFileInOS,
+ label: ctx.i18n.t('editor.action-label.reveal-current-file-in-os'),
+ run () {
+ const filePath = ctx.store.state.currentFile?.absolutePath
+ if (filePath) {
+ ctx.base.showItemInFolder(filePath)
+ }
+ }
})
- monaco.languages.setLanguageConfiguration('markdown', {
- onEnterRules: [
- { beforeText: /^\s*> .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '> ' } },
- { beforeText: /^\s*\+ \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
- { beforeText: /^\s*- \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
- { beforeText: /^\s*\* \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
- { beforeText: /^\s*\+ \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
- { beforeText: /^\s*- \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
- { beforeText: /^\s*\* \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
- { beforeText: /^\s*\+ .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ ' } },
- { beforeText: /^\s*- .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- ' } },
- { beforeText: /^\s*\* .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* ' } },
- { beforeText: /^\s*1. .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '1. ' } }
- ]
+ editor.addAction({
+ id: idRefreshCurrentDoc,
+ label: ctx.i18n.t('editor.action-label.refresh-current-document'),
+ run () {
+ ctx.view.refresh()
+ }
})
+ })
- monaco.languages.registerCompletionItemProvider('markdown', {
- triggerCharacters: Array(93).fill(undefined).map((_, i) => String.fromCharCode(i + 33)).concat(['~']),
- provideCompletionItems: (model, position) => {
- const lineContent = model.getLineContent(position.lineNumber)
- let startColumn = lineContent.substring(0, position.column).lastIndexOf(' ') + 1
- if (startColumn === position.column) {
- startColumn = 0
- }
-
- let endColumn = lineContent.substring(position.column - 1).indexOf(' ') + position.column
- if (endColumn < position.column) {
- endColumn = lineContent.length + 1
- }
-
- const range = {
- startLineNumber: position.lineNumber,
- endLineNumber: position.lineNumber,
- startColumn: startColumn + 1,
- endColumn: endColumn
- }
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push(
+ {
+ id: idInsertTime,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.insert-time'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idInsertTime) || []),
+ onClick: insertTime,
+ },
+ {
+ id: idInsertDate,
+ type: 'normal',
+ title: ctx.i18n.t('editor.context-menu.insert-date'),
+ subTitle: ctx.keybinding.getKeysLabel(ctx.editor.lookupKeybindingKeys(idInsertDate) || []),
+ onClick: insertDate,
+ },
+ )
+ })
- return {
- suggestions: createDependencyProposals(range)
- }
- }
- })
+ ctx.action.registerAction({
+ name: 'plugin.editor.focus-editor',
+ description: ctx.i18n.t('command-desc.plugin_editor_focus-editor'),
+ handler: focusEditor,
+ forUser: true,
+ keys: [ctx.keybinding.Shift, ctx.keybinding.Alt, 'x']
})
}
} as Plugin
diff --git a/src/renderer/plugins/editor-md-list.ts b/src/renderer/plugins/editor-md-list.ts
new file mode 100644
index 000000000..4887e1539
--- /dev/null
+++ b/src/renderer/plugins/editor-md-list.ts
@@ -0,0 +1,329 @@
+import type * as Monaco from 'monaco-editor'
+import { getLineContent, getOneIndent } from '@fe/services/editor'
+import type { Plugin } from '@fe/context'
+import { getSetting } from '@fe/services/setting'
+import { isKeydown } from '@fe/core/keybinding'
+
+const emptyItemReg = /^\s*(?:[*+\->]|\d+[.)]|[*+-] \[ \])\s*$/
+const unorderedListReg = /^\s*[*+-]\s/
+const orderedListReg = /^(\s*)(\d+)([.)])(\s)/
+const emptyLineReg = /^\s*$/
+
+let ignoreTabProcess = false
+
+function processCursorChange (editor: Monaco.editor.IStandaloneCodeEditor, monaco: typeof Monaco, e: Monaco.editor.ICursorPositionChangedEvent) {
+ const model = editor.getModel()
+ if (e.reason !== 0 || !model) {
+ return
+ }
+
+ const source = 'list-completion'
+ const isTab = e.source === 'tab'
+ const isOutdent = e.source === 'outdent'
+ const isDeleteLeft = e.source === 'deleteLeft'
+ const isEnter = (e.source === 'keyboard' || e.source === 'editor.action.insertLineAfter') && isKeydown('ENTER')
+ const isSpace = e.source === 'keyboard' && isKeydown(' ')
+
+ if (!isTab && !isDeleteLeft && !isEnter && !isSpace && !isOutdent) {
+ return false
+ }
+
+ const cursorAtEnd = model.getLineMaxColumn(e.position.lineNumber) === e.position.column
+
+ const tryKeepCursorAtEnd = () => {
+ if (cursorAtEnd) {
+ // force set position to the end of line
+ editor.setPosition(new monaco.Position(e.position.lineNumber, model.getLineMaxColumn(e.position.lineNumber)))
+ }
+ }
+
+ const processTab = (position: Monaco.Position) => {
+ const currentLine = model.getLineContent(position.lineNumber)
+ if (!currentLine) {
+ return
+ }
+
+ const eolNumber = model.getLineMaxColumn(position.lineNumber)
+
+ if (
+ eolNumber === position.column &&
+ /^\s*(?:[*+\->]|\d+[.)])/.test(currentLine)
+ ) {
+ const indent = getOneIndent()
+ const val = currentLine.trimEnd()
+ const end = /[-+*\].>)]$/.test(val) ? ' ' : ''
+ editor.pushUndoStop()
+ editor.executeEdits(source, [
+ {
+ range: new monaco.Range(position.lineNumber, 1, position.lineNumber, eolNumber),
+ text: indent + val + end
+ },
+ ])
+ }
+ }
+
+ const processEnter = (position: Monaco.Position) => {
+ const line = position.lineNumber
+
+ if (line < 2) {
+ return
+ }
+
+ const content = getLineContent(line)
+ const prevContent = getLineContent(line - 1)
+ if (
+ emptyItemReg.test(content) && // current line content must a empty item
+ emptyItemReg.test(prevContent) // next line content must a empty item
+ ) {
+ editor.pushUndoStop()
+ editor.executeEdits(source, [
+ {
+ range: new monaco.Range(line - 1, 1, line, model.getLineMaxColumn(line)),
+ text: '',
+ forceMoveMarkers: true
+ }
+ ])
+ return true
+ }
+ }
+
+ if (isTab) {
+ if (!ignoreTabProcess) {
+ processTab(e.position)
+ tryKeepCursorAtEnd()
+ }
+ } else if (isEnter) {
+ if (processEnter(e.position)) {
+ return // skip auto ordered list completion
+ }
+ }
+
+ const orderedListCompletion = getSetting('editor.ordered-list-completion', 'auto')
+
+ if (orderedListCompletion === 'off') {
+ return
+ }
+
+ const maxLineCount = model.getLineCount()
+
+ const processOrderedList = (position: Monaco.Position) => {
+ const line = position.lineNumber
+ if (line < 2) {
+ return
+ }
+
+ let startLine = line - 1
+ let endLine = line + 1
+ const prevLines = []
+ const nextLines = []
+ const currentLine = model.getLineContent(line)
+ const prefix = currentLine.slice(0, position.column - 1)
+
+ // check current line is an ordered list item
+ const match = currentLine.match(orderedListReg)
+ if (!match) {
+ return
+ }
+
+ const indent = match[1]
+
+ // if press space key, only auto complete when cursor at the start of line
+ if (isSpace && !emptyItemReg.test(prefix)) {
+ return
+ }
+
+ // if press delete left key, only auto complete when cursor at the end of line
+ if (isDeleteLeft && model.getLineMaxColumn(line) !== position.column) {
+ return
+ }
+
+ // 1. outdent a <- break
+ // 1. aaa <- matched
+ // 2. bbb <- matched
+ // 1. bbb.aaa <- matched
+ // 2. bbb.bbb <- matched
+ // 3. ccc <- matched
+ // CCC <- matched
+ // 4. ddd <- [*]cursor here
+ // 5. eee <- matched
+ // 1. eee.aaa <- matched
+ // 6. ddd <- matched
+ // 2. outdent b <- break
+ const matchContent = (content: string) => {
+ if (emptyLineReg.test(content)) { // empty line
+ return false
+ }
+
+ if (unorderedListReg.test(content)) { // unordered list
+ return false
+ }
+
+ const m = content.match(orderedListReg)
+ if (m && m[1].length < indent.length) { // outdent
+ return false
+ }
+
+ return true
+ }
+
+ while (startLine > 0) {
+ const content = model.getLineContent(startLine)
+ if (!matchContent(content)) {
+ break
+ }
+
+ // if we are here, it means the line is ordered list item (same or deeper indent)
+ prevLines.unshift(content)
+ startLine--
+ }
+
+ startLine++
+
+ while (endLine <= maxLineCount) {
+ const content = model.getLineContent(endLine)
+ if (!matchContent(content)) {
+ break
+ }
+
+ // if we are here, it means the line is ordered list item (same or deeper indent)
+ nextLines.push(content)
+ endLine++
+ }
+
+ endLine--
+
+ // if orderedListCompletion is auto, only auto complete when previous 2 lines are ordered list item
+ if (orderedListCompletion === 'auto' && prevLines.length < 2) {
+ return
+ }
+
+ const firstLine = prevLines[0]
+ const firstMatch = firstLine ? firstLine.match(orderedListReg) : null
+ const startNum = firstMatch ? parseInt(firstMatch[2]) : 1
+ let shouldInc = orderedListCompletion === 'increase'
+
+ if (orderedListCompletion === 'auto') {
+ const secondLine = prevLines[1]
+ const secondMatch = secondLine ? secondLine.match(orderedListReg) : null
+ shouldInc = secondMatch ? parseInt(secondMatch[2]) > 1 : false
+ }
+
+ const changedLines: number[] = []
+ let seq = 0
+ const text = [...prevLines, currentLine, ...nextLines].map((line, i) => {
+ const replaced = line.replace(orderedListReg, (s, p1, p2, p3, p4) => {
+ if (p1 !== indent) {
+ return s
+ }
+
+ const num = shouldInc ? (seq++) + startNum : startNum
+ return `${p1}${num}${p3}${p4}`
+ })
+
+ if (replaced !== line) {
+ changedLines.push(i)
+ }
+
+ return replaced
+ })
+
+ if (!changedLines.length) {
+ return
+ }
+
+ const changedLineStart = changedLines[0]
+ const changedLineEnd = changedLines[changedLines.length - 1]
+
+ return {
+ text: text.slice(changedLineStart, changedLineEnd + 1),
+ startLine: startLine + changedLineStart,
+ endLine: startLine + changedLineEnd
+ }
+ }
+
+ const doEdits = (position: Monaco.Position) => {
+ const edits: Monaco.editor.IIdentifiedSingleEditOperation[] = [position].map(p => {
+ const result = processOrderedList(p)
+ if (!result) {
+ return null
+ }
+
+ return {
+ range: new monaco.Range(result.startLine, 1, result.endLine, model.getLineMaxColumn(result.endLine)),
+ text: result.text.join(model.getEOL()),
+ } satisfies Monaco.editor.IIdentifiedSingleEditOperation
+ }).filter(Boolean) as Monaco.editor.IIdentifiedSingleEditOperation[]
+
+ // apply edits
+ if (edits.length) {
+ editor.pushUndoStop()
+ editor.executeEdits(source, edits)
+ tryKeepCursorAtEnd()
+ }
+ }
+
+ doEdits(e.position)
+
+ // if press tab key, auto complete the next outdent line
+ if ((isTab || isOutdent)) {
+ // find the next outdent line
+ let outdentLine: number = 0
+ const lineCount = model.getLineCount()
+ const currentLine = model.getLineContent(e.position.lineNumber)
+ const currentLineIndent = currentLine.match(orderedListReg)?.[1]
+
+ if (typeof currentLineIndent !== 'string') return
+
+ let line = e.position.lineNumber + 1
+ while (line < lineCount) {
+ const content = model.getLineContent(line)
+ const m = content.match(orderedListReg)
+ if (!m) return
+
+ if (m[1].length < currentLineIndent.length) {
+ outdentLine = line
+ break
+ }
+
+ line++
+ }
+
+ if (outdentLine) {
+ doEdits(new monaco.Position(outdentLine, 1))
+ }
+ }
+}
+
+export default {
+ name: 'editor-md-list',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
+ editor.onDidChangeCursorPosition(e => {
+ processCursorChange(editor, monaco, e)
+ })
+
+ // ignore tab process when cursor at the start of line
+ editor.onKeyDown(e => {
+ ignoreTabProcess = false
+ if (e.keyCode === monaco.KeyCode.Tab && !e.shiftKey && !e.altKey) {
+ const position = editor.getPosition()
+ const model = editor.getModel()
+
+ if (position && model) {
+ // get before cursor content
+ const line = model.getValueInRange({
+ startLineNumber: position.lineNumber,
+ startColumn: 1,
+ endLineNumber: position.lineNumber,
+ endColumn: position.column
+ })
+
+ if (line.trim() === '') {
+ ignoreTabProcess = true
+ }
+ }
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-md-syntax.ts b/src/renderer/plugins/editor-md-syntax.ts
new file mode 100644
index 000000000..f042f42ae
--- /dev/null
+++ b/src/renderer/plugins/editor-md-syntax.ts
@@ -0,0 +1,278 @@
+/* eslint-disable no-template-curly-in-string */
+import type * as Monaco from 'monaco-editor'
+import type { Ctx, Plugin } from '@fe/context'
+
+const surroundingPairs = [
+ { open: '{', close: '}' },
+ { open: '[', close: ']' },
+ { open: '(', close: ')' },
+ { open: '<', close: '>' },
+ { open: '`', close: '`' },
+ { open: "'", close: "'" },
+ { open: '"', close: '"' },
+ { open: '*', close: '*' },
+ { open: '_', close: '_' },
+ { open: '=', close: '=' },
+ { open: '~', close: '~' },
+ { open: '^', close: '^' },
+ { open: '#', close: '#' },
+ { open: '$', close: '$' },
+ { open: '《', close: '》' },
+ { open: '〈', close: '〉' },
+ { open: '【', close: '】' },
+ { open: '「', close: '」' },
+ { open: '（', close: '）' },
+ { open: '“', close: '”' },
+]
+
+const autoClosingPairs = [
+ { open: '{', close: '}' },
+ { open: '[', close: ']' },
+ { open: '(', close: ')' },
+ { open: '《', close: '》' },
+ { open: '〈', close: '〉' },
+ { open: '【', close: '】' },
+ { open: '「', close: '」' },
+ { open: '（', close: '）' },
+]
+
+class MdSyntaxCompletionProvider implements Monaco.languages.CompletionItemProvider {
+ triggerCharacters = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'.split('')
+
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ private readonly pairsMap = new Map(surroundingPairs.map(x => [x.open, x.close]))
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ private getRangeColumnOffset (type: 'suffix' | 'prefix', line: string, insertText: string) {
+ if (!line || !insertText) {
+ return 0
+ }
+
+ insertText = insertText.replace(/\$\{[0-9]+:([^}]+)?\}/g, '$1')
+ .replace(/\$\[0-9]/g, '')
+
+ const len = Math.min(line.length, insertText.length)
+
+ if (type === 'suffix') {
+ for (let i = len; i >= 0; i--) {
+ if (line.startsWith(insertText.slice(insertText.length - i))) {
+ return i
+ }
+ }
+ } else {
+ for (let i = len; i >= 0; i--) {
+ if (line.endsWith(insertText.slice(0, i))) {
+ return i
+ }
+ }
+ }
+
+ return 0
+ }
+
+ private async provideSelectionCompletionItems (model: Monaco.editor.IModel, selection: Monaco.Selection, languageId: string): Promise {
+ const selectionEndLineMaxColumn = model.getLineMaxColumn(selection.endLineNumber)
+ const items = this.ctx.editor.getSimpleCompletionItems().filter(item => {
+ if (item.language && item.language !== languageId) {
+ return false
+ }
+
+ if (item.insertText.includes('${TM_SELECTED_TEXT}')) {
+ return true
+ }
+
+ const surroundSelectionSnippet = typeof item.surroundSelection === 'function'
+ ? item.surroundSelection(item.insertText, selection, model)
+ : typeof item.surroundSelection === 'string'
+ ? item.insertText.replace(item.surroundSelection, '$TM_SELECTED_TEXT')
+ : undefined
+
+ if (surroundSelectionSnippet) {
+ const allowBlock = selection.startColumn === 1 && selection.endColumn === selectionEndLineMaxColumn
+ item.insertText = surroundSelectionSnippet
+
+ if (item.block && !allowBlock) {
+ return false
+ }
+
+ return true
+ }
+
+ return false
+ })
+
+ const result: Monaco.languages.CompletionItem[] = items.map((item, i) => {
+ const range = new this.monaco.Range(
+ selection.startLineNumber,
+ selection.startColumn,
+ selection.endLineNumber,
+ selection.endColumn,
+ )
+
+ return {
+ label: { label: item.label },
+ kind: item.kind || this.monaco.languages.CompletionItemKind.Keyword,
+ insertText: item.insertText,
+ insertTextRules: this.monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+ range: this.monaco.Range.spansMultipleLines(range) ? range.collapseToStart() : range,
+ sortText: i.toString().padStart(7),
+ detail: item.detail,
+ }
+ })
+
+ return { suggestions: result }
+ }
+
+ public async provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Promise {
+ const languageId = this.ctx.editor.getLineLanguageId(position.lineNumber, model)
+
+ const selection = this.ctx.editor.getEditor().getSelection()!
+ if (!selection.isEmpty()) {
+ return this.provideSelectionCompletionItems(model, selection, languageId)
+ }
+
+ const line = model.getLineContent(position.lineNumber)
+ const cursor = position.column - 1
+ const linePrefixText = line.slice(0, cursor)
+ const lineSuffixText = line.slice(cursor)
+
+ let startColumn = linePrefixText.lastIndexOf(' ') + 2
+ if (startColumn === position.column) {
+ startColumn = 0
+ }
+
+ const items = this.ctx.editor.getSimpleCompletionItems().filter((item) => {
+ if (item.language && item.language !== languageId) {
+ return false
+ }
+
+ return !item.block || startColumn === 1
+ })
+
+ const result: Monaco.languages.CompletionItem[] = items.map((item, i) => {
+ let columnOffset = this.getRangeColumnOffset('suffix', lineSuffixText, item.insertText)
+ if (columnOffset === 0) {
+ // remove auto surrounding pairs
+ columnOffset = this.pairsMap.get(line.charAt(cursor - 1)) === line.charAt(cursor) ? 1 : 0
+ }
+
+ const range = new this.monaco.Range(
+ position.lineNumber,
+ startColumn,
+ position.lineNumber,
+ position.column + columnOffset,
+ )
+
+ return {
+ label: { label: item.label },
+ kind: item.kind || this.monaco.languages.CompletionItemKind.Keyword,
+ insertText: item.insertText,
+ insertTextRules: this.monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+ range,
+ sortText: i.toString().padStart(7),
+ detail: item.detail,
+ command: item.command,
+ }
+ })
+
+ return { suggestions: result }
+ }
+}
+
+export default {
+ name: 'editor-md-syntax',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new MdSyntaxCompletionProvider(monaco, ctx)
+ )
+
+ monaco.languages.setLanguageConfiguration('markdown', {
+ surroundingPairs,
+ autoClosingPairs,
+ onEnterRules: [
+ { beforeText: /^\s*> .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '> ' } },
+ { beforeText: /^\s*\+ \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
+ { beforeText: /^\s*- \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
+ { beforeText: /^\s*\* \[ \] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
+ { beforeText: /^\s*\+ \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ [ ] ' } },
+ { beforeText: /^\s*- \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- [ ] ' } },
+ { beforeText: /^\s*\* \[x\] .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* [ ] ' } },
+ { beforeText: /^\s*\+ .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '+ ' } },
+ { beforeText: /^\s*- .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '- ' } },
+ { beforeText: /^\s*\* .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: '* ' } },
+ { beforeText: /^\s*\d+\. .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: { toString: () => ctx.setting.getSetting('editor.ordered-list-completion') === 'off' ? '' : '1. ' } as string } },
+ { beforeText: /^\s*\d+\) .*$/, action: { indentAction: monaco.languages.IndentAction.None, appendText: { toString: () => ctx.setting.getSetting('editor.ordered-list-completion') === 'off' ? '' : '1) ' } as string } },
+ ]
+ })
+
+ monaco.languages.registerCodeActionProvider('*', {
+ provideCodeActions (_model: Monaco.editor.ITextModel, range: Monaco.Range): Monaco.languages.CodeActionList {
+ const enabled = ctx.setting.getSetting('editor.enable-trigger-suggest-bulb', true)
+ if (!enabled || range.isEmpty() || (range as Monaco.Selection).getDirection?.() === monaco.SelectionDirection.LTR) {
+ return { dispose: () => 0, actions: [] }
+ }
+
+ const actionTitle = ctx.i18n.t('trigger-suggestions')
+ const actionId = 'editor.action.triggerSuggest'
+
+ const actions: Monaco.languages.CodeAction[] = [{
+ title: actionTitle,
+ command: { id: actionId, title: actionTitle },
+ kind: 'refactor',
+ diagnostics: [],
+ isPreferred: true,
+ }]
+
+ return { dispose: () => 0, actions }
+ },
+ })
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ items.unshift(
+ { language: 'markdown', label: '/ ![]() Image', insertText: '' },
+ { language: 'markdown', label: '/ []() Link', insertText: '[${2:Link}]($1)' },
+ { language: 'markdown', label: '/ # Head 1', insertText: '# $1', block: true },
+ { language: 'markdown', label: '/ ## Head 2', insertText: '## $1', block: true },
+ { language: 'markdown', label: '/ ### Head 3', insertText: '### $1', block: true },
+ { language: 'markdown', label: '/ #### Head 4', insertText: '#### $1', block: true },
+ { language: 'markdown', label: '/ ##### Head 5', insertText: '##### $1', block: true },
+ { language: 'markdown', label: '/ ###### Head 6', insertText: '###### $1', block: true },
+ { language: 'markdown', label: '/ + List', insertText: '+ ' },
+ { language: 'markdown', label: '/ - List', insertText: '- ' },
+ { language: 'markdown', label: '/ > Blockquote', insertText: '> ' },
+ { language: 'markdown', label: '/ ` Code', insertText: '`$1`', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ * Italic', insertText: '*$1*', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ _ Italic', insertText: '_$1_', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ~ Sub', insertText: '~$1~', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ^ Sup', insertText: '^$1^', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ** Bold', insertText: '**$1**', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ __ Bold', insertText: '__$1__', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ~~ Delete', insertText: '~~$1~~', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ == Mark', insertText: '==$1==', surroundSelection: '$1', },
+ { language: 'markdown', label: '/ ``` Fence', insertText: '```$1\n$2\n```\n', block: true, surroundSelection: '$2', },
+ { language: 'markdown', label: '/ --- Horizontal Line', insertText: '---\n', block: true },
+ { language: 'markdown', label: '/ + [ ] TODO List', insertText: '+ [ ] ' },
+ { language: 'markdown', label: '/ - [ ] TODO List', insertText: '- [ ] ' },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/^\s*[+\-*] \[[ xX]\]\s/, 'keyword'],
+ [/==\S.*?\S?==/, 'keyword'],
+ [/(!?\[\[)([^[\]]+)(\]\])/, ['keyword.predefined', 'string', 'keyword.predefined']],
+ [/~\S[^~]*\S?~/, 'string'],
+ [/\^\S[^^]*\S?\^/, 'string'],
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-paste.ts b/src/renderer/plugins/editor-paste.ts
index a75184b91..5cc5c665d 100644
--- a/src/renderer/plugins/editor-paste.ts
+++ b/src/renderer/plugins/editor-paste.ts
@@ -1,49 +1,65 @@
+import dayjs from 'dayjs'
import TurndownService from 'turndown'
-import { getEditor, insert } from '@fe/context/editor'
-import type { Plugin } from '@fe/context/plugin'
-import * as api from '@fe/support/api'
+import { gfm } from 'joplin-turndown-plugin-gfm'
+import { getEditor, insert } from '@fe/services/editor'
+import { Plugin } from '@fe/context'
+import { triggerHook } from '@fe/core/hook'
+import { refreshTree } from '@fe/services/tree'
+import { upload } from '@fe/services/base'
import store from '@fe/support/store'
-import { encodeMarkdownLink, fileToBase64URL } from '@fe/utils'
+import { encodeMarkdownLink, fileToBase64URL, path } from '@fe/utils'
+import { isKeydown } from '@fe/core/keybinding'
-let keys: {[key: string]: boolean} = {}
-
-function recordKeys (e: KeyboardEvent) {
- if (e.type === 'keydown') {
- keys[e.key] = true
- } else {
- keys = {}
- }
-}
+const IMAGE_REG = /^image\//i
+const HTML_REG = /^text\/html$/i
async function pasteHtml (html: string) {
- const md = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced', bulletListMarker: '+' }).turndown(html)
- insert(md)
+ const td = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced', bulletListMarker: '+' })
+ td.use(gfm)
+ const md = td.turndown(html)
+ insert(md + '\n')
}
-async function pasteImage (file: any, asBase64: boolean) {
+async function pasteImage (file: File, asBase64: boolean) {
if (asBase64) {
const uri = await fileToBase64URL(file)
- insert(`\n`)
+ insert(`\n`)
} else {
if (!store.state.currentFile) {
- throw new Error('当前未打开文件')
+ throw new Error('No file opened.')
}
- const { repo, path } = store.state.currentFile
- const { relativePath } = await api.upload(repo, path, file)
- insert(`})\n`)
+ const ext = path.extname(file.name)
+ const filename = `img-${dayjs().format('YYYYMMDDHHmmss')}${ext}`
+
+ file = new File([file], filename, { type: file.type })
+
+ if (!(await triggerHook('EDITOR_PASTE_IMAGE', { file }, { breakable: true }))) {
+ const assetPath = await upload(file, store.state.currentFile, file.name)
+ insert(`})\n`)
+ }
+
+ refreshTree()
}
}
+let selectedTextBeforePaste = ''
+
function paste (e: ClipboardEvent) {
- if (!getEditor().hasTextFocus()) {
+ selectedTextBeforePaste = ''
+ const editor = getEditor()
+ if (!editor.hasTextFocus()) {
return
}
- const items = e.clipboardData!.items
- if (keys.d || keys.D) { // 粘贴 HTML 转为 markdown
+ if (e.clipboardData === null) {
+ return
+ }
+
+ const items = e.clipboardData.items
+ if (isKeydown('D')) { // covert RFT to markdown
for (let i = 0; i < items.length; i++) {
- if (items[i].type.match(/^text\/html$/i)) {
+ if (items[i].type.match(HTML_REG)) {
items[i].getAsString(pasteHtml)
}
}
@@ -53,19 +69,177 @@ function paste (e: ClipboardEvent) {
} else {
for (let i = 0; i < items.length; i++) {
const fileType = items[i].type
- if (fileType.match(/^image\/(png|jpg|jpeg|gif)$/i)) {
- const asBase64 = keys.b || keys.B // 粘贴的同时 按下了 B 键，就粘贴 base64 图像
- pasteImage(items[i].getAsFile(), asBase64)
+ if (IMAGE_REG.test(fileType)) {
+ e.preventDefault()
+ e.stopPropagation()
+ const asBase64 = isKeydown('B') // press key b, paste image as base64
+ pasteImage(items[i].getAsFile()!, asBase64)
}
}
}
+
+ // normal paste
+ // only one selection
+ if (editor.getSelections()?.length === 1) {
+ const selection = editor.getSelection()
+ if (selection && !selection.isEmpty()) {
+ selectedTextBeforePaste = editor.getModel()?.getValueInRange(selection) || ''
+ }
+ }
}
export default {
name: 'editor-paste',
- register: () => {
+ register: (ctx) => {
window.addEventListener('paste', paste as any, true)
- window.addEventListener('keydown', recordKeys, true)
- window.addEventListener('keyup', recordKeys, true)
+
+ const pasteImageAsBase64ActionId = 'plugin.editor-paste.insert-image-base64'
+ const pasteRtfActionId = 'plugin.editor-paste.insert-rt'
+
+ const pasteImageFromClipboard = async (asBase64: boolean) => {
+ ctx.base.readFromClipboard(async (type, getType) => {
+ if (IMAGE_REG.test(type)) {
+ const ext = ctx.lib.mime.getExtension(type)
+ const file = new File([await getType(type)], 'image.' + ext, { type })
+ await pasteImage(file, asBase64)
+ const { editor } = await ctx.editor.whenEditorReady()
+ editor.focus()
+ }
+ })
+ }
+
+ const pasteRtf = () => {
+ ctx.base.readFromClipboard(async (type, getType) => {
+ if (type.match(HTML_REG)) {
+ const html = await (await getType(type)).text()
+ await pasteHtml(html)
+ const { editor } = await ctx.editor.whenEditorReady()
+ editor.focus()
+ }
+ })
+ }
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push(
+ {
+ id: pasteImageAsBase64ActionId,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.insert.paste-img-base64'),
+ subTitle: 'Base64',
+ onClick: () => {
+ pasteImageFromClipboard(true)
+ }
+ },
+ {
+ id: pasteRtfActionId,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.insert.paste-rt'),
+ subTitle: 'Markdown',
+ onClick: pasteRtf
+ },
+ { type: 'separator' },
+ )
+ })
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.addAction({
+ id: 'plugin.editor-paste.insert-image',
+ label: ctx.i18n.t('editor.context-menu.paste-image'),
+ contextMenuGroupId: 'clipboard',
+ contextMenuOrder: 1,
+ run: async () => {
+ pasteImageFromClipboard(false)
+ }
+ })
+
+ editor.addAction({
+ id: pasteImageAsBase64ActionId,
+ label: ctx.i18n.t('editor.context-menu.paste-image-as-base64'),
+ contextMenuGroupId: 'clipboard',
+ contextMenuOrder: 2,
+ run: () => {
+ pasteImageFromClipboard(true)
+ }
+ })
+
+ editor.addAction({
+ id: pasteRtfActionId,
+ label: ctx.i18n.t('editor.context-menu.paste-rt-as-markdown'),
+ contextMenuGroupId: 'clipboard',
+ contextMenuOrder: 3,
+ run: pasteRtf,
+ })
+
+ editor.onDidPaste(({ range }) => {
+ const model = editor.getModel()
+ const languageId = model?.getLanguageId()
+ const parsedText = model?.getValueInRange(range) || ''
+
+ // paste link as markdown link
+ if (selectedTextBeforePaste && languageId === 'markdown' && !selectedTextBeforePaste.includes('\n')) {
+ const isLink = (str: string) => {
+ if (!/^https?:\/\//i.test(str)) {
+ return false
+ }
+
+ try {
+ // eslint-disable-next-line no-new
+ new URL(str)
+ return true
+ } catch (_) {
+ return false
+ }
+ }
+
+ const parsedTextIsLink = isLink(parsedText)
+ const selectedTextBeforePasteIsLink = isLink(selectedTextBeforePaste)
+
+ // both are link, do nothing
+ if (parsedTextIsLink && selectedTextBeforePasteIsLink) {
+ return
+ }
+
+ // is link
+ if (parsedText && parsedTextIsLink) {
+ const text = `[${
+ selectedTextBeforePaste.replace(/([[\]])/g, '\\$1')
+ }](${encodeMarkdownLink(parsedText)})`
+ editor.executeEdits('paste', [{ range, text }])
+ return
+ } else if (selectedTextBeforePasteIsLink) {
+ const text = `[${
+ parsedText.replace(/([[\]])/g, '\\$1').trim()
+ }](${encodeMarkdownLink(selectedTextBeforePaste)})`
+ editor.executeEdits('paste', [{ range, text }])
+ return
+ }
+ }
+
+ // paste splitted by tab as table
+ if (languageId === 'markdown') {
+ const lines = parsedText.replace(/^\n+|\n+$/g, '').split('\n')
+ if (lines.length > 2) {
+ let rows = []
+ for (const line of lines) {
+ const columns = line.split('\t')
+ if (columns.length >= 2) {
+ rows.push(`| ${columns.join(' | ')} |`)
+ } else {
+ rows = []
+ break
+ }
+ }
+
+ if (rows.length > 1) {
+ // add header
+ rows.splice(1, 0, rows[0].replace(/[^|]+/g, ' -- '))
+ editor.executeEdits('paste', [{ range, text: rows.join('\n') }])
+ }
+ }
+ }
+
+ selectedTextBeforePaste = ''
+ })
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/editor-path-completion.ts b/src/renderer/plugins/editor-path-completion.ts
new file mode 100644
index 000000000..94f6bd233
--- /dev/null
+++ b/src/renderer/plugins/editor-path-completion.ts
@@ -0,0 +1,459 @@
+// https://github.com/microsoft/vscode/blob/main/extensions%2Fmarkdown-language-features%2Fsrc%2Ffeatures%2FpathCompletions.ts
+
+import type Markdown from 'markdown-it'
+import type * as Monaco from 'monaco-editor'
+import type { Ctx, Plugin } from '@fe/context'
+import type { Components } from '@fe/types'
+import type Token from 'markdown-it/lib/token'
+import { MARKDOWN_FILE_EXT } from '@share/misc'
+
+enum CompletionContextKind {
+ Link, // [...](|)
+
+ WikiLink, // [[|]]
+
+ ReferenceLink, // [...][|]
+
+ LinkDefinition, // []: | // TODO: not implemented
+}
+
+interface AnchorContext {
+ /**
+ * Link text before the `#`.
+ *
+ * For `[text](xy#z|abc)` this is `xy`.
+ */
+ readonly beforeAnchor: string;
+ /**
+ * Text of the anchor before the current position.
+ *
+ * For `[text](xy#z|abc)` this is `z`.
+ */
+ readonly anchorPrefix: string;
+}
+
+interface CompletionContext {
+ readonly kind: CompletionContextKind;
+
+ /**
+ * Text of the link before the current position
+ *
+ * For `[text](xy#z|abc)` this is `xy#z`.
+ */
+ readonly linkPrefix: string;
+
+ /**
+ * Position of the start of the link.
+ *
+ * For `[text](xy#z|abc)` this is the position before `xy`.
+ */
+ readonly linkTextStartPosition: Monaco.Position;
+
+ /**
+ * Text of the link after the current position.
+ *
+ * For `[text](xy#z|abc)` this is `abc`.
+ */
+ readonly linkSuffix: string;
+
+ /**
+ * Info if the link looks like it is for an anchor: `[](#header)`
+ */
+ readonly anchorInfo?: AnchorContext;
+}
+
+class CompletionProvider implements Monaco.languages.CompletionItemProvider {
+ triggerCharacters = ['/', ':', '#', '[']
+
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+ private readonly markdown: Markdown
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ // eslint-disable-next-line new-cap
+ this.markdown = new ctx.lib.markdownit()
+ }
+
+ public async provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Promise {
+ const context = this.getPathCompletionContext(model, position)
+ if (!context) {
+ return { suggestions: [] }
+ }
+
+ switch (context.kind) {
+ case CompletionContextKind.ReferenceLink: {
+ return {
+ suggestions: Array.from(
+ this.provideReferenceSuggestions(this.ctx.view.getRenderEnv()?.source || model.getValue(), position, context)
+ )
+ }
+ }
+
+ case CompletionContextKind.LinkDefinition:
+ case CompletionContextKind.WikiLink:
+ case CompletionContextKind.Link: {
+ const items: Monaco.languages.CompletionItem[] = []
+
+ const isAnchorInCurrentDoc = context.anchorInfo && context.anchorInfo.beforeAnchor.length === 0
+
+ // Add anchor #links in current doc
+ if (context.linkPrefix.length === 0 || isAnchorInCurrentDoc) {
+ const insertRange = new this.monaco.Range(
+ context.linkTextStartPosition.lineNumber,
+ context.linkTextStartPosition.column,
+ position.lineNumber,
+ position.column
+ )
+
+ const tokens = this.ctx.view.getRenderEnv()?.tokens || []
+
+ for await (const item of this.provideHeaderSuggestions(tokens, context, position, insertRange)) {
+ items.push(item)
+ }
+ }
+
+ if (!isAnchorInCurrentDoc) {
+ if (context.anchorInfo) { // Anchor to a different document
+ const currentFile = this.ctx.store.state.currentFile
+ if (!currentFile || !context.anchorInfo.beforeAnchor.endsWith(MARKDOWN_FILE_EXT)) {
+ return { suggestions: [] }
+ }
+
+ const filePath = this.ctx.utils.path.resolve(
+ this.ctx.utils.path.dirname(currentFile.path),
+ context.anchorInfo.beforeAnchor
+ )
+
+ const { content } = await this.ctx.api.readFile({ repo: currentFile.repo, path: filePath })
+ if (content) {
+ const anchorStartPosition = position.delta(0, -(context.anchorInfo.anchorPrefix.length + 1))
+ const range = new this.monaco.Range(
+ anchorStartPosition.lineNumber,
+ anchorStartPosition.column,
+ position.lineNumber,
+ position.column,
+ )
+
+ for await (const item of this.provideHeaderSuggestions(content, context, position, range)) {
+ items.push(item)
+ }
+ }
+ } else { // Normal path suggestions
+ for await (const item of this.providePathSuggestions(position, context)) {
+ items.push(item)
+ }
+ }
+ }
+
+ return { suggestions: items }
+ }
+ }
+ }
+
+ /// [...](...|
+ private readonly linkStartPattern = /\[([^\]]*?)\]\(\s*([^\s()]*)$/
+
+ /// [[...|
+ private readonly wikiLinkStartPattern = /\[\[\s*([^[\]]*)$/
+
+ /// [...|
+ private readonly referenceLinkStartPattern = /\[\s*([^\s[\]]*)$/
+
+ /// [id]: |
+ private readonly definitionPattern = /^\s*\[[\w-]+\]:\s*([^\s]*)$/m
+
+ private readonly defPattern = /^([\t ]*\[(?!\^)((?:\\\]|[^\]])+)\]:\s*)([^<]\S*|<[^>]+>)/gm
+
+ private readonly angleBracketLinkRe = /^<(.*)>$/
+
+ private getPathCompletionContext (model: Monaco.editor.IModel, position: Monaco.Position): CompletionContext | undefined {
+ const line = model.getLineContent(position.lineNumber)
+
+ const cursor = position.column - 1
+ const linePrefixText = line.slice(0, cursor)
+ const lineSuffixText = line.slice(cursor)
+
+ const linkPrefixMatch = linePrefixText.match(this.linkStartPattern)
+ if (linkPrefixMatch) {
+ const prefix = linkPrefixMatch[2]
+ if (this.refLooksLikeUrl(prefix)) {
+ return undefined
+ }
+
+ const suffix = lineSuffixText.match(/^[^)\s]*/)
+
+ return {
+ kind: CompletionContextKind.Link,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ anchorInfo: this.getAnchorContext(prefix),
+ }
+ }
+
+ const wikiLinkPrefixMatch = linePrefixText.match(this.wikiLinkStartPattern)
+ if (wikiLinkPrefixMatch) {
+ const prefix = wikiLinkPrefixMatch[1]
+ const suffix = lineSuffixText.match(/^[^\]]*/)
+ return {
+ kind: CompletionContextKind.WikiLink,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ anchorInfo: this.getAnchorContext(prefix),
+ }
+ }
+
+ const definitionLinkPrefixMatch = linePrefixText.match(this.definitionPattern)
+ if (definitionLinkPrefixMatch) {
+ const prefix = definitionLinkPrefixMatch[1]
+ if (this.refLooksLikeUrl(prefix)) {
+ return undefined
+ }
+
+ const suffix = lineSuffixText.match(/^[^\s]*/)
+ return {
+ kind: CompletionContextKind.LinkDefinition,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ anchorInfo: this.getAnchorContext(prefix),
+ }
+ }
+
+ const referenceLinkPrefixMatch = linePrefixText.match(this.referenceLinkStartPattern)
+ if (referenceLinkPrefixMatch) {
+ const prefix = referenceLinkPrefixMatch[1]
+ const suffix = lineSuffixText.match(/^[^\]\s]*/)
+ return {
+ kind: CompletionContextKind.ReferenceLink,
+ linkPrefix: prefix,
+ linkTextStartPosition: position.delta(0, -prefix.length),
+ linkSuffix: suffix ? suffix[0] : '',
+ }
+ }
+
+ return undefined
+ }
+
+ /**
+ * Check if {@param ref} looks like a 'http:' style url.
+ */
+ private refLooksLikeUrl (prefix: string): boolean {
+ return /^\s*[\w\d-]+:/.test(prefix)
+ }
+
+ private getAnchorContext (prefix: string): AnchorContext | undefined {
+ const anchorMatch = prefix.match(/^(.*)#([\w\d-]*)$/)
+ if (!anchorMatch) {
+ return undefined
+ }
+
+ let beforeAnchor = anchorMatch[1]
+
+ if (anchorMatch[1] && !this.ctx.utils.path.extname(beforeAnchor)) {
+ beforeAnchor += MARKDOWN_FILE_EXT
+ }
+
+ return {
+ beforeAnchor,
+ anchorPrefix: anchorMatch[2],
+ }
+ }
+
+ private async * providePathSuggestions (position: Monaco.Position, context: CompletionContext): AsyncIterable {
+ let idx = context.linkPrefix.lastIndexOf('/')
+
+ if (context.kind === CompletionContextKind.WikiLink) {
+ idx = Math.max(context.linkPrefix.lastIndexOf(':'), idx)
+ }
+
+ const valueBeforeLastSlash = context.linkPrefix.substring(0, idx + 1) // keep the last slash
+
+ const currentFile = this.ctx.store.state.currentFile
+ if (!currentFile) {
+ return
+ }
+
+ const basePath = this.ctx.utils.path.dirname(currentFile.path)
+
+ const parentDir = context.kind === CompletionContextKind.WikiLink
+ ? this.ctx.utils.path.resolve(basePath, valueBeforeLastSlash.replace(/:/g, '/') || '.')
+ : this.ctx.utils.path.resolve(basePath, valueBeforeLastSlash || '.')
+
+ const pathSegmentStart = position.delta(0, valueBeforeLastSlash.length - context.linkPrefix.length)
+ const insertRange = new this.monaco.Range(
+ pathSegmentStart.lineNumber,
+ pathSegmentStart.column,
+ position.lineNumber,
+ position.column
+ )
+
+ const pathSegmentEnd = position.delta(0, context.linkSuffix.length)
+ const replacementRange = new this.monaco.Range(
+ pathSegmentStart.lineNumber,
+ pathSegmentStart.column,
+ pathSegmentEnd.lineNumber,
+ pathSegmentEnd.column,
+ )
+
+ const items = await this.getFileList(parentDir)
+
+ let i = 0
+ for (const item of items) {
+ i++
+ const isDir = item.type === 'dir'
+ let label = isDir ? item.name + '/' : item.name
+ let insertText = this.ctx.utils.encodeMarkdownLink(label)
+
+ // Remove extension for wiki links
+ if (context.kind === CompletionContextKind.WikiLink) {
+ label = label.replace(/\.(md|markdown)$/, '')
+ insertText = label.replaceAll(']', ']').replaceAll('[', '[')
+ }
+
+ yield {
+ label,
+ insertText,
+ kind: isDir ? this.monaco.languages.CompletionItemKind.Folder : this.monaco.languages.CompletionItemKind.File,
+ range: {
+ insert: insertRange,
+ replace: replacementRange,
+ },
+ command: isDir ? { id: 'editor.action.triggerSuggest', title: '' } : undefined,
+ sortText: i.toString().padStart(7),
+ }
+ }
+ }
+
+ private async getFileList (parentDir: string): Promise {
+ const result: Components.Tree.Node[] = []
+
+ const traverseTree = (nodes: Components.Tree.Node[]) => {
+ nodes.forEach(node => {
+ if (node.type === 'dir') {
+ if (parentDir.startsWith(node.path)) {
+ traverseTree(node.children || [])
+
+ if (node.path === parentDir) {
+ result.push(...(node.children || []))
+ }
+ }
+ }
+ })
+ }
+
+ const repo = this.ctx.store.state.currentFile?.repo
+
+ if (!repo) {
+ return result
+ }
+
+ if (this.ctx.store.state.currentFile?.repo === this.ctx.store.state.currentRepo?.name) {
+ traverseTree(this.ctx.store.state.tree || [])
+ } else {
+ const tree = await this.ctx.api.fetchTree(repo, { by: 'name', order: 'asc' }, undefined, true)
+ traverseTree(tree)
+ }
+
+ return result
+ }
+
+ private async * provideHeaderSuggestions (tokensOrContent: string | Token[], context: CompletionContext, position: Monaco.Position, insertionRange: Monaco.Range): AsyncIterable {
+ const tokens = typeof tokensOrContent === 'string' ? this.markdown.parse(tokensOrContent, []) : tokensOrContent
+ const endPos = position.delta(0, context.linkSuffix.length)
+ const replacementRange = new this.monaco.Range(
+ insertionRange.startLineNumber,
+ insertionRange.startColumn,
+ endPos.lineNumber,
+ endPos.column
+ )
+
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i]
+ if (token.type === 'heading_open') {
+ const nextToken = tokens[i + 1]
+ if (nextToken && nextToken.content) {
+ const id = nextToken.content.trim().replace(/\s+/g, '-')
+ yield {
+ kind: this.monaco.languages.CompletionItemKind.Reference,
+ label: '# ' + tokens[i].tag.toUpperCase() + ' ' + nextToken.content,
+ insertText: '#' + this.ctx.utils.encodeMarkdownLink(id),
+ range: {
+ insert: insertionRange,
+ replace: replacementRange,
+ },
+ sortText: i.toString().padStart(7)
+ }
+ }
+ }
+ }
+ }
+
+ private * provideReferenceSuggestions (text: string, position: Monaco.Position, context: CompletionContext): Iterable {
+ const insertionRange = new this.monaco.Range(
+ context.linkTextStartPosition.lineNumber,
+ context.linkTextStartPosition.column,
+ position.lineNumber,
+ position.column,
+ )
+
+ const replacementPos = position.delta(0, context.linkSuffix.length)
+
+ const replacementRange = new this.monaco.Range(
+ insertionRange.startLineNumber,
+ insertionRange.startColumn,
+ replacementPos.lineNumber,
+ replacementPos.column,
+ )
+
+ const definitions = this.getDefinitions(text)
+ let i = 0
+ for (const def of definitions) {
+ i++
+ yield {
+ kind: this.monaco.languages.CompletionItemKind.Reference,
+ label: def[0],
+ insertText: def[0],
+ range: {
+ insert: insertionRange,
+ replace: replacementRange,
+ },
+ sortText: i.toString().padStart(7)
+ }
+ }
+ }
+
+ private getDefinitions (text: string) {
+ const out = new Map()
+ for (const match of text.matchAll(this.defPattern)) {
+ const reference = match[2]
+ const link = match[3].trim()
+
+ if (this.angleBracketLinkRe.test(link)) {
+ out.set(reference, {
+ link: link.substring(1, link.length - 1),
+ })
+ } else {
+ out.set(reference, {
+ link,
+ })
+ }
+ }
+ return out
+ }
+}
+
+export default {
+ name: 'editor-md-completion',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new CompletionProvider(monaco, ctx)
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-restore-state.ts b/src/renderer/plugins/editor-restore-state.ts
new file mode 100644
index 000000000..ba1982d81
--- /dev/null
+++ b/src/renderer/plugins/editor-restore-state.ts
@@ -0,0 +1,87 @@
+import type { Plugin } from '@fe/context'
+import { registerHook } from '@fe/core/hook'
+import type { editor } from 'monaco-editor'
+
+export default {
+ name: 'editor-restore-state',
+ register: (ctx) => {
+ const logger = ctx.utils.getLogger('plugin:editor-restore-state')
+ const storageKey = 'plugin.editor-state'
+
+ const viewStateCache = ctx.lib.vue.shallowReactive>(ctx.storage.get(storageKey, {}))
+
+ ctx.lib.vue.watch(viewStateCache, () => {
+ // keep recent 10 view states
+ const entries = Object.entries(viewStateCache)
+ .sort((a, b) => b[1]._t - a[1]._t)
+ .slice(0, 10)
+
+ ctx.storage.set(storageKey, Object.fromEntries(entries))
+ })
+
+ function saveState (uri: editor.ITextModel['uri'] | null | undefined, viewState: editor.ICodeEditorViewState | null) {
+ if (!uri) return
+
+ const uriStr = uri.toString()
+ logger.debug('save view state', uriStr)
+ viewStateCache[uriStr] = {
+ _t: Date.now(),
+ v: viewState
+ }
+ }
+
+ const saveStateDebounced = ctx.lib.lodash.debounce(saveState, 500)
+
+ registerHook('DOC_BEFORE_SWITCH', () => {
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ const uri = editor.getModel()?.uri
+ if (!uri) return
+ const viewState = editor.saveViewState()
+ saveState(uri, viewState)
+ })
+ })
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.onDidChangeModel((e) => {
+ const uri = e.newModelUrl?.toString()
+ if (!uri) return
+ const viewState = viewStateCache[uri]
+ if (viewState && viewState.v) {
+ logger.debug('restore view state', uri)
+ editor.restoreViewState(viewState.v)
+ }
+ })
+
+ editor.onDidChangeCursorPosition(() => {
+ saveStateDebounced(editor.getModel()?.uri, editor.saveViewState())
+ })
+
+ editor.onDidScrollChange(() => {
+ saveStateDebounced(editor.getModel()?.uri, editor.saveViewState())
+ })
+ })
+
+ ctx.lib.vue.watch(() => ctx.store.state.tabs, () => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ const uris = ctx.store.state.tabs.map(x => x.key)
+
+ // clean view state
+ for (const uri of Object.keys(viewStateCache)) {
+ if (!uris.includes(uri)) {
+ logger.debug('dispose view state', uri)
+ delete viewStateCache[uri]
+ }
+ }
+
+ // clean models
+ const models = monaco.editor.getModels()
+ for (const model of models) {
+ if (model.uri.scheme === ctx.doc.URI_SCHEME && !uris.includes(model.uri.toString())) {
+ logger.debug('dispose model', model.uri.toString())
+ model.dispose()
+ }
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/editor-words.ts b/src/renderer/plugins/editor-words.ts
new file mode 100644
index 000000000..5f48cf037
--- /dev/null
+++ b/src/renderer/plugins/editor-words.ts
@@ -0,0 +1,80 @@
+import type * as Monaco from 'monaco-editor'
+import type { Ctx, Plugin } from '@fe/context'
+
+function getWords (content: string) {
+ const words = new Set()
+
+ if (content.length > 102400) {
+ return words
+ }
+
+ const identifier = /[a-zA-Z_]+\w/g
+
+ while (true) {
+ if (words.size > 1000) {
+ break
+ }
+
+ const res = identifier.exec(content)
+ if (!res) {
+ break
+ }
+
+ if (res[0].length > 2 && res[0].length < 15) {
+ words.add(res[0])
+ }
+ }
+
+ return words
+}
+
+class WordsCompletionProvider implements Monaco.languages.CompletionItemProvider {
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ public async provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Promise {
+ const selection = this.ctx.editor.getEditor().getSelection()
+ if (!selection?.isEmpty()) { // only trigger when no selection
+ return
+ }
+
+ const currentWord = model.getWordUntilPosition(position)
+ const result: Monaco.languages.CompletionItem[] = []
+
+ getWords(model.getValue()).forEach((word, i) => {
+ if (currentWord.word !== word) {
+ result.push({
+ label: { label: word },
+ kind: this.monaco.languages.CompletionItemKind.Text,
+ insertText: word,
+ range: new this.monaco.Range(
+ position.lineNumber,
+ currentWord.startColumn,
+ position.lineNumber,
+ currentWord.endColumn,
+ ),
+ sortText: i.toString().padStart(7)
+ })
+ }
+ })
+
+ return { suggestions: result }
+ }
+}
+
+export default {
+ name: 'editor-words',
+ register: (ctx) => {
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new WordsCompletionProvider(monaco, ctx)
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/electron-zoom.ts b/src/renderer/plugins/electron-zoom.ts
new file mode 100644
index 000000000..44facc1b5
--- /dev/null
+++ b/src/renderer/plugins/electron-zoom.ts
@@ -0,0 +1,88 @@
+import type { Plugin } from '@fe/context'
+import type { BuildInActionName } from '@fe/types'
+
+export default {
+ name: 'electron-zoom',
+ register: (ctx) => {
+ if (!ctx.env.isElectron) {
+ return
+ }
+
+ ctx.registerHook('STARTUP', () => {
+ const webContents = ctx.env.getElectronRemote().getCurrentWebContents()
+
+ function setZoomFactor (factor: number) {
+ webContents.setZoomFactor(factor)
+ ctx.statusBar.refreshMenu()
+ }
+
+ function changeZoomFactor (zoomIn: boolean) {
+ const currentZoomFactor = webContents.getZoomFactor()
+ const factor = currentZoomFactor + (zoomIn ? 0.1 : -0.1)
+
+ if (factor > 0.2 && factor < 2) {
+ setZoomFactor(factor)
+ }
+ }
+
+ const zoomInId: BuildInActionName = 'plugin.electron-zoom.zoom-in'
+ const zoomOutId: BuildInActionName = 'plugin.electron-zoom.zoom-out'
+ const zoomResetId: BuildInActionName = 'plugin.electron-zoom.zoom-reset'
+
+ ctx.action.registerAction({
+ name: zoomInId,
+ keys: [ctx.keybinding.CtrlCmd, '='],
+ description: ctx.i18n.t('command-desc.plugin_electron-zoom_zoom-in'),
+ forUser: true,
+ handler: () => changeZoomFactor(true)
+ })
+
+ ctx.action.registerAction({
+ name: zoomOutId,
+ keys: [ctx.keybinding.CtrlCmd, '-'],
+ description: ctx.i18n.t('command-desc.plugin_electron-zoom_zoom-out'),
+ forUser: true,
+ handler: () => changeZoomFactor(false)
+ })
+
+ ctx.action.registerAction({
+ name: zoomResetId,
+ keys: [ctx.keybinding.CtrlCmd, '0'],
+ description: ctx.i18n.t('command-desc.plugin_electron-zoom_zoom-reset'),
+ forUser: true,
+ handler: () => setZoomFactor(1)
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ const factor = ctx.env.getElectronRemote().getCurrentWebContents().getZoomFactor()
+ menus['status-bar-view']?.list?.push(
+ { type: 'separator' },
+ {
+ id: zoomInId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('electron-zoom.zoom-in'),
+ disabled: factor >= 1.9,
+ subTitle: ctx.keybinding.getKeysLabel(zoomInId),
+ onClick: () => ctx.action.getActionHandler(zoomInId)()
+ },
+ {
+ id: zoomOutId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('electron-zoom.zoom-out'),
+ disabled: factor < 0.25,
+ subTitle: ctx.keybinding.getKeysLabel(zoomOutId),
+ onClick: () => ctx.action.getActionHandler(zoomOutId)()
+ },
+ {
+ id: zoomResetId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('electron-zoom.zoom-reset'),
+ disabled: factor === 1,
+ subTitle: ctx.keybinding.getKeysLabel(zoomResetId),
+ onClick: () => ctx.action.getActionHandler(zoomResetId)()
+ },
+ )
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/emoji.ts b/src/renderer/plugins/emoji.ts
new file mode 100644
index 000000000..8bc9ce371
--- /dev/null
+++ b/src/renderer/plugins/emoji.ts
@@ -0,0 +1,110 @@
+import type * as Monaco from 'monaco-editor'
+import MarkdownItEmoji from 'markdown-it-emoji/dist/full.cjs.js'
+import emoji from 'markdown-it-emoji/lib/data/full.mjs'
+import type { Ctx, Plugin } from '@fe/context'
+
+const triggerCharacter = ':'
+
+class EmojiCompletionProvider implements Monaco.languages.CompletionItemProvider {
+ public readonly triggerCharacters = [triggerCharacter]
+
+ private readonly monaco: typeof Monaco
+ private readonly ctx: Ctx
+
+ constructor (monaco: typeof Monaco, ctx: Ctx) {
+ this.monaco = monaco
+ this.ctx = ctx
+ }
+
+ public provideCompletionItems (model: Monaco.editor.IModel, position: Monaco.Position): Monaco.languages.CompletionList {
+ if (!this.ctx.setting.getSetting('editor.complete-emoji')) {
+ return { suggestions: [] }
+ }
+
+ const line = model.getLineContent(position.lineNumber)
+ const cursor = position.column - 1
+ const linePrefixText = line.slice(0, cursor)
+
+ // check language id
+ if (this.ctx.editor.getLineLanguageId(position.lineNumber, model) !== 'markdown') {
+ return { suggestions: [] }
+ }
+
+ // Check if the cursor is in a wiki link
+ if (linePrefixText.lastIndexOf('[[') > linePrefixText.lastIndexOf(']]')) {
+ return { suggestions: [] }
+ }
+
+ const match = linePrefixText.match(/:[a-zA-Z0-9]*$/)
+ if (!match || linePrefixText.charAt(linePrefixText.length - match[0].length - 1) === ':') {
+ return { suggestions: [] }
+ }
+
+ const startPos = position.delta(0, -match[0].length)
+
+ const result: Monaco.languages.CompletionItem[] = []
+ Object.keys(emoji).forEach((key, i) => {
+ result.push({
+ label: { label: `:${key}:${(emoji as any)[key]}` },
+ kind: this.monaco.languages.CompletionItemKind.EnumMember,
+ insertText: (emoji as any)[key],
+ range: new this.monaco.Range(
+ position.lineNumber,
+ startPos.column,
+ position.lineNumber,
+ position.column
+ ),
+ sortText: i.toString().padStart(7),
+ })
+ })
+
+ return { suggestions: result }
+ }
+}
+
+export default {
+ name: 'editor-emoji',
+ register: (ctx) => {
+ ctx.markdown.registerPlugin(md => {
+ md.use(MarkdownItEmoji)
+
+ md.renderer.rules.emoji = (token, idx) => {
+ return ctx.lib.vue.createVNode(ctx.lib.vue.Text, null, token[idx].content) as any
+ }
+ })
+
+ ctx.editor.whenEditorReady().then(({ monaco }) => {
+ monaco.languages.registerCompletionItemProvider(
+ 'markdown',
+ new EmojiCompletionProvider(monaco, ctx)
+ )
+ })
+
+ ctx.setting.changeSchema(schema => {
+ schema.properties['render.md-emoji'] = {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.render.md-emoji',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'render',
+ required: true,
+ }
+ schema.properties['editor.complete-emoji'] = {
+ defaultValue: true,
+ title: 'T_setting-panel.schema.editor.complete-emoji',
+ type: 'boolean',
+ format: 'checkbox',
+ group: 'editor',
+ required: true,
+ }
+ })
+
+ ctx.registerHook('MARKDOWN_BEFORE_RENDER', ({ md }) => {
+ if (ctx.setting.getSetting('render.md-emoji')) {
+ md.enable('emoji', true)
+ } else {
+ md.disable('emoji', true)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/file-tree-functions.ts b/src/renderer/plugins/file-tree-functions.ts
new file mode 100644
index 000000000..247376a47
--- /dev/null
+++ b/src/renderer/plugins/file-tree-functions.ts
@@ -0,0 +1,143 @@
+import { Plugin, Ctx } from '@fe/context'
+import { isNormalRepo } from '@fe/services/repo'
+import { FLAG_DISABLE_XTERM } from '@fe/support/args'
+import type { Components, Doc } from '@fe/types'
+
+export default {
+ name: 'file-tree-context-menu',
+ register: (ctx: Ctx) => {
+ function revealInXterminal (node: Doc) {
+ const { currentRepo } = ctx.store.state
+ const path = currentRepo ? ctx.utils.path.join(currentRepo.path, node.path) : ''
+ if (path) {
+ ctx.action.getActionHandler('xterm.run')(`--yank-note-run-command-cd-- ${path}`)
+ }
+ }
+
+ function addItem (node: Doc) {
+ const input = window.document.createElement('input')
+ input.type = 'file'
+ input.multiple = true
+ input.onchange = async () => {
+ for (let i = 0; i < input.files!.length; i++) {
+ const file = input.files![i]
+ const fileBase64Url = await ctx.utils.fileToBase64URL(file)
+ const filePath = ctx.utils.path.resolve(node.path, file.name)
+ await ctx.api.upload(node.repo, fileBase64Url, filePath)
+ }
+
+ ctx.tree.refreshTree()
+ }
+ input.click()
+ }
+
+ function getItems (node: Components.Tree.Node, position: 'tabs' | 'tree'): Components.ContextMenu.Item[] {
+ const t = ctx.i18n.t
+
+ const disableItems = ctx.args.FLAG_READONLY
+ ? ['add-item', 'duplicate', 'duplicate', 'create-dir', 'create-doc', 'create-in-cd', 'rename', 'delete', 'open-in-terminal']
+ : []
+
+ if (position === 'tabs') {
+ disableItems.push('refresh')
+ }
+
+ return [
+ ...(node.type === 'dir' ? [
+ { id: 'create-doc', label: t('tree.context-menu.create-doc'), onClick: () => ctx.doc.createDoc({ repo: node.repo }, node), ellipsis: true },
+ { id: 'create-dir', label: t('tree.context-menu.create-dir'), onClick: () => ctx.doc.createDir({ repo: node.repo }, node), ellipsis: true },
+ { id: 'add-item', label: t('tree.context-menu.add-item'), onClick: () => addItem(node), ellipsis: true },
+ ] : []),
+ ...(node.path !== '/' ? [
+ { id: 'rename', label: t('tree.context-menu.rename'), onClick: () => ctx.doc.moveDoc(node), ellipsis: true },
+ { id: 'delete', label: t('tree.context-menu.delete'), onClick: () => ctx.doc.deleteDoc(node), ellipsis: true },
+ ] : []),
+ ...(!ctx.doc.isEncrypted(node) ? [
+ { id: 'duplicate', label: t('tree.context-menu.duplicate'), onClick: () => ctx.doc.duplicateDoc(node), ellipsis: true },
+ ] : []),
+ { type: 'separator' },
+ { id: 'open-in-os', label: t('tree.context-menu.open-in-os'), onClick: () => ctx.doc.openInOS(node) },
+ ...(node.type === 'file' ? [
+ { id: 'reveal-in-os', label: t('tree.context-menu.reveal-in-os'), onClick: () => ctx.doc.openInOS(node, true) }
+ ] : []),
+ { id: 'refresh', label: t('tree.context-menu.refresh'), onClick: () => ctx.tree.refreshTree() },
+ ...(node.type === 'dir' ? [
+ { id: 'find-in-folder', label: t('tree.context-menu.find-in-folder'), onClick: () => ctx.base.findInRepository({ include: node.path.replace(/^\//, '') + '/**/*.md' }), ellipsis: true },
+ ] : []),
+ ...(node.type === 'dir' && !FLAG_DISABLE_XTERM ? [
+ { id: 'open-in-terminal', label: t('tree.context-menu.open-in-terminal'), onClick: () => revealInXterminal(node) },
+ ] : []),
+ { id: 'create-in-cd', label: t('tree.context-menu.create-in-cd'), onClick: () => ctx.doc.createDoc({ repo: node.repo }, node), ellipsis: true },
+ { type: 'separator' },
+ { id: 'copy-name', label: t('tree.context-menu.copy-name'), onClick: () => ctx.utils.copyText(node.name) },
+ { id: 'copy-path', label: t('tree.context-menu.copy-path'), onClick: () => ctx.utils.copyText(node.path) }
+ ].filter((x: any) => (!x.id || !disableItems.includes(x.id))) as Components.ContextMenu.Item[]
+ }
+
+ ctx.tree.tapContextMenus((items, node, vueCtx) => {
+ async function toggleMark () {
+ if ((node as any).marked) {
+ vueCtx.localMarked.value = false
+ await ctx.doc.unmarkDoc(node)
+ } else {
+ vueCtx.localMarked.value = true
+ await ctx.doc.markDoc(node)
+ }
+
+ node.marked = vueCtx.localMarked.value
+ }
+
+ const t = ctx.i18n.t
+
+ items.push(...[
+ ...(ctx.doc.supported(node) ? [
+ {
+ id: 'mark',
+ label: node.marked ? t('tree.context-menu.unmark') : t('tree.context-menu.mark'),
+ onClick: () => toggleMark()
+ },
+ ] : []),
+ ...getItems(node, 'tree')
+ ])
+ })
+
+ ctx.workbench.FileTabs.tapTabContextMenus((items, tab) => {
+ const doc: Doc | null = tab.payload.file
+
+ if (!doc || doc.type !== 'file' || !isNormalRepo(doc.repo)) {
+ return
+ }
+
+ items.push(...getItems(doc as Components.Tree.Node, 'tabs'))
+ })
+
+ async function createFile (node: Components.Tree.Node) {
+ await ctx.doc.createDoc({ repo: node.repo }, node)
+ }
+
+ async function createFolder (node: Components.Tree.Node) {
+ await ctx.doc.createDir({ repo: node.repo }, node)
+ }
+
+ ctx.tree.tapNodeActionButtons((btns, node) => {
+ if (ctx.args.FLAG_READONLY || node.type !== 'dir') {
+ return
+ }
+
+ btns.push(
+ {
+ id: 'create-folder',
+ title: ctx.i18n.t('tree.context-menu.create-dir'),
+ icon: 'folder-plus-solid',
+ onClick: () => createFolder(node)
+ },
+ {
+ id: 'create-file',
+ title: ctx.i18n.t('tree.context-menu.create-doc'),
+ icon: 'plus',
+ onClick: () => createFile(node)
+ }
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/get-started/GetStarted.vue b/src/renderer/plugins/get-started/GetStarted.vue
new file mode 100644
index 000000000..7187f9d70
--- /dev/null
+++ b/src/renderer/plugins/get-started/GetStarted.vue
@@ -0,0 +1,225 @@
+
+ => {
+ const canvas = document.createElement('canvas')
+ canvas.width = ximg.naturalWidth
+ canvas.height = ximg.naturalHeight
+ canvas.getContext('2d')!.drawImage(ximg, 0, 0)
+ return new Promise((resolve, reject) => {
+ canvas.toBlob(async blob => {
+ try {
+ const imgFile = new File([blob!], 'file.png')
+ const assetPath = await upload(imgFile, currentFile)
+ resolve(assetPath)
+ } catch (error) {
+ reject(error)
+ }
+ })
+ })
+ }
+
+ let replacedLink = ''
+ const imgAttrSrc = img.getAttribute('src') || ''
+ if (img.src.startsWith('data:')) {
+ replacedLink = await transform(img)
+ } else if (imgAttrSrc.startsWith('http://') || imgAttrSrc.startsWith('https://')) {
+ const headers = JSON.parse(img.getAttribute('headers') || '{}')
+ const res = await api.proxyFetch(img.src, { headers })
+ const blob = await res.blob()
+ const contentType = res.headers.get('content-type') || ''
+
+ if (!contentType.startsWith('image/')) {
+ throw new Error('Not an image')
+ }
+
+ const ext = mime.getExtension(contentType) || ''
+ const imgFile = new File([blob!], 'file.' + ext)
+ const name = removeQuery(img.src).split('/').pop() // get file name from url
+ const assetPath = await upload(
+ imgFile,
+ currentFile,
+ ext === name?.split('.').pop() ? name : undefined // if ext is not same as file name, use file name
+ )
+ replacedLink = assetPath
+ }
+
+ if (replacedLink) {
+ return { oldLink: img.src, replacedLink: encodeMarkdownLink(replacedLink) }
+ }
+
+ return null
+}
+
+const actionKeydown: BuildInActionName = 'plugin.image-localization.download-all'
+const commandClick = 'plugin.image-localization.single-by-click'
+
+async function transformAll () {
+ const refView = getViewDom()
+ if (!refView) {
+ return
+ }
+
+ const toast = useToast()
+
+ const result = []
+ const imgList = refView.querySelectorAll('img')
+ for (let i = 0; i < imgList.length; i++) {
+ toast.show('info', `${i + 1}/${imgList.length}`)
+
+ const img = imgList[i]
+ const data = await transformImgOutLink(img)
+ if (data) {
+ result.push(data)
+ }
+ }
+ result.forEach(data => replaceValue(data.oldLink, data.replacedLink))
+ refreshTree()
+}
+
+export default {
+ name: 'image-localization',
+ register: (ctx) => {
+ function when () {
+ const currentFile = ctx.store.state.currentFile
+ const previewFile = ctx.view.getRenderEnv()?.file
+
+ return !!(currentFile && ctx.editor.isDefault() && ctx.doc.isSameFile(currentFile, previewFile))
+ }
+
+ ctx.action.registerAction({
+ name: actionKeydown,
+ handler: transformAll,
+ description: ctx.i18n.t('command-desc.plugin_image-localization_all'),
+ forUser: true,
+ when,
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ if (!when()) return
+
+ menus['status-bar-tool']?.list?.push(
+ {
+ id: actionKeydown,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.tool.convert-img-link'),
+ onClick: ctx.action.getActionHandler(actionKeydown)
+ },
+ )
+ })
+
+ ctx.view.tapContextMenus((items, e) => {
+ if (!when()) return
+
+ const el = e.target as HTMLElement
+
+ if (
+ el.tagName === 'IMG' &&
+ /^https:\/\/|^http:\/\/|^data:/.test(el.getAttribute('src') || '')
+ ) {
+ items.push({
+ id: commandClick,
+ type: 'normal',
+ label: ctx.i18n.t('status-bar.tool.convert-img-link'),
+ onClick: async () => {
+ try {
+ ctx.ui.useToast().show('info', 'Loading……', 0)
+ const data = await transformImgOutLink(el as HTMLImageElement)
+ if (data) {
+ replaceValue(data.oldLink, data.replacedLink)
+ refreshTree()
+ }
+ ctx.ui.useToast().hide()
+ } catch (error: any) {
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ })
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/image-viewer.ts b/src/renderer/plugins/image-viewer.ts
deleted file mode 100644
index 1af14d57d..000000000
--- a/src/renderer/plugins/image-viewer.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { debounce } from 'lodash-es'
-import Viewer from 'viewerjs'
-import type { Plugin } from '@fe/context/plugin'
-import 'viewerjs/dist/viewer.css'
-
-let viewer: any
-
-export default {
- name: 'image-viewer',
- register: ctx => {
- ctx.registerHook('ON_VIEW_RENDERED', debounce(({ getViewDom }) => {
- if (!viewer) {
- viewer = new Viewer(getViewDom(), { zIndex: 299999 })
- }
-
- viewer.update()
- }, 500))
-
- ctx.theme.addStyles(`
- body .viewer-backdrop,
- body .viewer-navbar {
- background: rgba(167, 167, 167, 0.6);
- }
- `)
- }
-} as Plugin
diff --git a/src/renderer/plugins/image-viewer.tsx b/src/renderer/plugins/image-viewer.tsx
new file mode 100644
index 000000000..91dbfbb18
--- /dev/null
+++ b/src/renderer/plugins/image-viewer.tsx
@@ -0,0 +1,173 @@
+import { defineComponent, onBeforeUnmount, onMounted, ref, watchEffect } from 'vue'
+import mime from 'mime'
+import { debounce } from 'lodash-es'
+import Viewer from 'viewerjs'
+import type { Plugin } from '@fe/context'
+import store from '@fe/support/store'
+import { getAttachmentURL } from '@fe/services/base'
+import { sleep } from '@fe/utils'
+import type { Doc } from '@fe/types'
+
+import 'viewerjs/dist/viewer.css'
+
+function isImageFile (doc?: Doc | null) {
+ if (!doc) {
+ return false
+ }
+
+ if (doc.name.toLowerCase().endsWith('.svg')) {
+ return true
+ }
+
+ if (doc.plain) {
+ return false
+ }
+
+ const fileMime = mime.getType(doc.name)
+ return !!fileMime && fileMime.startsWith('image/')
+}
+
+const ImageViewer = defineComponent({
+ setup () {
+ const img = ref()
+ let viewer: Viewer | null = null
+
+ function clean () {
+ if (viewer) {
+ viewer.destroy()
+ viewer = null
+ }
+ }
+
+ onMounted(() => {
+ watchEffect(async () => {
+ const doc = store.state.currentFile
+ if (doc && img.value && isImageFile(doc)) {
+ clean()
+ await sleep(0)
+ viewer = new Viewer(img.value, {
+ inline: true,
+ navbar: false,
+ fullscreen: false,
+ button: false,
+ backdrop: false,
+ transition: false,
+ toolbar: {
+ zoomIn: true,
+ zoomOut: true,
+ flipHorizontal: true,
+ flipVertical: true,
+ oneToOne: true,
+ reset: true,
+ rotateLeft: true,
+ rotateRight: true,
+ },
+ url () {
+ return getAttachmentURL(doc)
+ },
+ })
+
+ await sleep(0)
+ }
+ })
+ })
+
+ onBeforeUnmount(clean)
+
+ return () => ![]()
+ }
+})
+
+export default {
+ name: 'image-viewer',
+ register: ctx => {
+ ctx.registerHook('VIEW_MOUNTED', () => {
+ setTimeout(() => {
+ const viewer = new Viewer(ctx.view.getViewDom()!, {
+ zIndex: 2.11e8,
+ container: document.body,
+ transition: false,
+ toolbar: {
+ zoomIn: 4,
+ zoomOut: 4,
+ oneToOne: 4,
+ reset: 4,
+ prev: 4,
+ play: 0,
+ next: 4,
+ rotateLeft: 4,
+ rotateRight: 4,
+ flipHorizontal: 4,
+ flipVertical: 4,
+ }
+ })
+
+ function wrapEventBind (fn: () => void) {
+ return function (this: any) {
+ const element = this.element
+ this.element = window.document.body
+ fn.call(this)
+ this.element = element
+ }
+ }
+
+ const _initList = (viewer as any).initList
+ ;(viewer as any).initList = function (this: any, ...args: any[]) {
+ // hack for viewerjs, when there are too many images, the navbar will be hidden
+ this.options.navbar = this.images.length <= 5
+ this.navbar.style.display = this.options.navbar ? 'block' : 'none'
+ return _initList.apply(viewer, args)
+ }
+
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // @ts-ignore
+ viewer.bind = wrapEventBind(viewer.bind)
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // @ts-ignore
+ viewer.unbind = wrapEventBind(viewer.unbind)
+
+ ctx.registerHook('VIEW_RENDERED', debounce(() => {
+ viewer.update()
+ }, 500))
+ }, 0)
+ })
+
+ ctx.theme.addStyles(`
+ body .viewer-backdrop {
+ background: rgba(var(--g-color-90-rgb), 0.98);
+ }
+
+ body .viewer-title {
+ color: #888;
+ }
+
+ body .viewer-navbar {
+ background: rgba(0, 0, 0, .57)
+ }
+
+ body .viewer-canvas > img {
+ transition: transform .2s;
+ }
+ `)
+
+ // https://github.com/fengyuanchen/viewerjs/issues/197
+ ctx.view.addStyles(`
+ body.viewer-open {
+ padding-right: 0 !important;
+ }
+ `, true)
+
+ ctx.editor.registerCustomEditor({
+ name: 'image-viewer',
+ displayName: 'Image Viewer',
+ hiddenPreview: true,
+ when ({ doc }) {
+ return isImageFile(doc)
+ },
+ component: ImageViewer,
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/insert-table/InsertTable.vue b/src/renderer/plugins/insert-table/InsertTable.vue
new file mode 100644
index 000000000..e2f164651
--- /dev/null
+++ b/src/renderer/plugins/insert-table/InsertTable.vue
@@ -0,0 +1,139 @@
+
+ ,
+ },
+ setup (props) {
+ const displayFlag = ref(false)
+
+ function hide () {
+ displayFlag.value = false
+ }
+
+ function show () {
+ displayFlag.value = true
+ }
+
+ registerHook('DOC_SWITCHED', hide)
+ registerHook('VIEW_BEFORE_REFRESH', hide)
+ registerHook('VIEW_RENDERED', show)
+
+ onBeforeUnmount(() => {
+ removeHook('DOC_SWITCHED', hide)
+ removeHook('VIEW_BEFORE_REFRESH', hide)
+ removeHook('VIEW_RENDERED', show)
+ })
+
+ return () => !displayFlag.value ? null : h(IFrame, {
+ html: props.html,
+ debounce: 1000,
+ globalStyle: true,
+ onLoad (iframe: HTMLIFrameElement) {
+ const win = iframe.contentWindow as any
+ win.appletId = props.appletId
+ win.init?.()
+ win.resize()
+ },
+ iframeProps: {
+ ...props.attrs,
+ class: 'applet-iframe',
+ height: '20px',
+ }
+ })
+ }
+})
const MarkdownItPlugin = (md: Markdown) => {
const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
- md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
const token = tokens[idx]
const code = token.content.trim()
const firstLine = code.split(/\n/)[0].trim()
- if (token.info !== 'html' || !firstLine.includes('--applet--')) {
+ if (token.info !== 'html' || !firstLine.includes('--applet--') || env.safeMode) {
return temp(tokens, idx, options, env, slf)
}
- const hash = CryptoJS.MD5(code).toString()
+ const hash = md5(code)
const appletId = `applet-${hash}-${idx}`
const appletTitle = firstLine.replace('', '').replace('--applet--', '').trim()
const html = `
${code}
`
+ const iframe = h(Applet, {
+ html,
+ appletId,
+ attrs: token.meta?.attrs,
+ })
+
+ if (!appletTitle) {
+ return iframe
+ }
+
return h('fieldset', {}, [
h('legend', {}, `Applet: ${appletTitle}`),
h('div',
{ class: 'applet' },
- h(IFrame, {
- html,
- debounce: 1000,
- globalStyle: true,
- onLoad (iframe: HTMLIFrameElement) {
- const win = iframe.contentWindow as any
- win.appletId = appletId
- win.CryptoJS = CryptoJS
- win.dayjs = dayjs
- win.init?.()
- win.resize()
- },
- iframeProps: {
- class: 'applet-iframe',
- height: '20px',
- }
- }),
+ iframe,
)
]) as any
}
@@ -59,5 +101,13 @@ export default {
name: 'applet',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin)
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` Applet', insertText: '```html\n\n\n```\n', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-code-copy.ts b/src/renderer/plugins/markdown-code-copy.ts
new file mode 100644
index 000000000..8d833360d
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-copy.ts
@@ -0,0 +1,109 @@
+import { h, VNode } from 'vue'
+import { Plugin } from '@fe/context'
+import SvgIcon from '@fe/components/SvgIcon.vue'
+
+export default {
+ name: 'markdown-code-copy',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .p-mcc-copy-btn-wrapper {
+ width: 0;
+ height: 0;
+ position: sticky;
+ left: 100%;
+ top: 0;
+ float: right;
+ }
+
+ .markdown-view .markdown-body .p-mcc-language {
+ position: absolute;
+ top: -11px;
+ right: -8px;
+ opacity: 1;
+ color: var(--g-color-50);
+ font-size: 12px;
+ transition: opacity 200ms;
+ user-select: none;
+ line-height: 1;
+ }
+
+ .markdown-view .markdown-body .p-mcc-copy-btn {
+ width: 20px;
+ height: 20px;
+ position: relative;
+ right: 12px;
+ top: -10px;
+ padding: 6px;
+ border-radius: 50%;
+ opacity: 0;
+ transition: opacity 200ms;
+ display: flex;
+ align-items: center;
+ color: var(--g-color-30)
+ }
+
+ .markdown-view .markdown-body pre:hover .p-mcc-copy-btn {
+ opacity: 1;
+ }
+
+ .markdown-view .markdown-body pre:hover .p-mcc-language {
+ opacity: 0;
+ }
+
+ .markdown-view .markdown-body .p-mcc-copy-btn:hover {
+ background: var(--g-color-80);
+ }
+
+ .markdown-view .markdown-body .svg-icon {
+ width: 18px;
+ height: 18px;
+ display: inline-block;
+ text-align: center;
+ vertical-align: middle;
+ }
+
+ .markdown-view .markdown-body .svg-icon svg {
+ width: 100%;
+ height: 100%;
+ display: inline-block;
+ }
+ `, true)
+
+ ctx.markdown.registerPlugin(md => {
+ const codeInline = (fn: Function) => (tokens: any, idx: any, options: any, env: any, slf: any) => {
+ if (tokens[idx].attrIndex('title') < 0) {
+ tokens[idx].attrJoin('class', ctx.args.DOM_CLASS_NAME.COPY_INNER_TEXT)
+ tokens[idx].attrPush(['title', ctx.keybinding.getKeyLabel('CtrlCmd') + ' + ' + ctx.i18n.t('click-to-copy')])
+ }
+
+ return (fn)(tokens, idx, options, env, slf)
+ }
+
+ const codeBlock = (fn: Function) => (tokens: any, idx: any, options: any, env: any, slf: any) => {
+ const token = tokens[idx]
+ const code = token.content
+ const codeNode: VNode = fn(tokens, idx, options, env, slf) as any
+
+ if (!code.trim()) {
+ return codeNode as any
+ }
+
+ if (codeNode && Array.isArray(codeNode.children)) {
+ codeNode.children.unshift(h('div', { class: 'p-mcc-copy-btn-wrapper skip-print' }, [
+ h('div', { class: 'p-mcc-language' }, token.info),
+ h(
+ 'div',
+ { class: 'p-mcc-copy-btn copy-text', 'data-text': code.replace(/\n$/, ''), title: ctx.i18n.t('copy-code') },
+ h(SvgIcon, { name: 'clipboard', style: 'pointer-events: none' })
+ ),
+ ]))
+ }
+
+ return codeNode as any
+ }
+
+ md.renderer.rules.fence = codeBlock(md.renderer.rules.fence!.bind(md.renderer.rules))
+ md.renderer.rules.code_inline = codeInline(md.renderer.rules.code_inline!.bind(md.renderer.rules))
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code-highlight.ts b/src/renderer/plugins/markdown-code-highlight.ts
new file mode 100644
index 000000000..4af12e1c8
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-highlight.ts
@@ -0,0 +1,285 @@
+import prism from 'prismjs'
+import defaultStyle from 'prismjs/themes/prism.css?inline'
+import { escape } from 'lodash-es'
+import type { Plugin, Ctx } from '@fe/context'
+import { getLogger } from '@fe/utils'
+import styles from '@fe/others/prism-style.scss?inline'
+import '@fe/others/prism-languages-all'
+
+const logger = getLogger('markdown-code-highlight')
+
+const TABLE_NAME = 'hljs-ln'
+const LINE_NAME = 'hljs-ln-line'
+const CODE_BLOCK_NAME = 'hljs-ln-code'
+const NUMBERS_BLOCK_NAME = 'hljs-ln-numbers'
+const NUMBER_LINE_NAME = 'hljs-ln-n'
+const DATA_ATTR_NAME = 'data-line-number'
+const BREAK_LINE_REGEXP = /\r\n|\r|\n/g
+
+function addCustomStyles (ctx: Ctx) {
+ ctx.view.addStyles(`
+ ${styles}
+
+ .markdown-view .markdown-body table.${TABLE_NAME} {
+ margin: 0;
+ border-collapse: separate;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME},
+ .markdown-view .markdown-body table.${TABLE_NAME} tr,
+ .markdown-view .markdown-body table.${TABLE_NAME} td {
+ border: 0;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td {
+ padding: 0;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} tbody {
+ display: table;
+ min-width: 100%;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td.${NUMBERS_BLOCK_NAME} {
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ text-align: center;
+ vertical-align: top;
+ text-align: right;
+ min-width: 2em;
+ width: 2em;
+ position: sticky;
+ left: 0;
+ background-color: var(--g-color-96);
+ box-shadow: -20px 0px 0px var(--g-color-96);
+ border-right: 1px solid var(--g-color-86);
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td.${CODE_BLOCK_NAME} {
+ padding-left: 10px;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} .${NUMBER_LINE_NAME}{
+ white-space: nowrap;
+ padding-right: 8px;
+ color: var(--g-color-40);
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} .${NUMBER_LINE_NAME}:before{
+ content: attr(${DATA_ATTR_NAME})
+ }
+
+ .markdown-view .markdown-body .${ctx.args.DOM_CLASS_NAME.WRAP_CODE} table.${TABLE_NAME} td {
+ white-space: pre-wrap;
+ box-shadow: none !important;
+ }
+
+ @media print {
+ .markdown-view .markdown-body table.${TABLE_NAME} tr {
+ background-color: inherit;
+ }
+
+ .markdown-view .markdown-body table.${TABLE_NAME} td {
+ white-space: pre-wrap;
+ box-shadow: none !important;
+ }
+ }
+
+ @media screen {
+ .markdown-view .markdown-body table.${TABLE_NAME} {
+ max-height: 400px;
+ }
+ }
+ `)
+}
+
+function getLinesCount (text: string) {
+ return (text.trim().match(BREAK_LINE_REGEXP) || []).length
+}
+
+function getLines (text: string) {
+ if (text.length === 0) return []
+ return text.split(BREAK_LINE_REGEXP)
+}
+
+function addLineNumbersBlockFor (inputHtml: string, firstLineIndex: number, lang: string) {
+ const lines = getLines(inputHtml)
+
+ if (lines.length === 0) {
+ return inputHtml
+ }
+
+ // if last line contains only carriage return remove it
+ if (lines[lines.length - 1].trim() === '') {
+ lines.pop()
+ }
+
+ if (lines.length > firstLineIndex) {
+ let html = ''
+
+ for (let i = 0, l = lines.length; i < l; i++) {
+ html += '' +
+ `` +
+ `` +
+ ' ' +
+ `` +
+ ` ' +
+ ' '
+ }
+
+ return `${html}
`
+ }
+
+ return inputHtml
+}
+
+function duplicateMultilineNode (element: HTMLElement) {
+ const className = element.className
+
+ if (!/^token/.test(className)) return
+
+ const lines = getLines(element.innerHTML)
+
+ let result = ''
+ for (let i = 0; i < lines.length; i++) {
+ const lineText = lines[i].length > 0 ? lines[i] : ' '
+ result += `${lineText}\n`
+ }
+
+ element.innerHTML = result.trim()
+}
+
+/**
+ * Recursive method for fix multi-line elements implementation
+ * Doing deep passage on child nodes.
+ */
+function duplicateMultilineNodes (element: HTMLElement) {
+ element.childNodes.forEach(child => {
+ if (child.textContent && getLinesCount(child.textContent) > 0) {
+ if (child.childNodes.length > 0) {
+ duplicateMultilineNodes(child as HTMLElement)
+ } else {
+ duplicateMultilineNode(child.parentNode! as HTMLElement)
+ }
+ }
+ })
+}
+
+function wrap (code: string, lang: string, lineNumber: boolean) {
+ let html = code
+
+ if (lang === 'text') {
+ html = escape(code)
+ }
+
+ if (lineNumber) {
+ const element = document.createElement('code')
+ element.innerHTML = html
+ duplicateMultilineNodes(element)
+ html = addLineNumbersBlockFor(element.innerHTML, 1, lang)
+ }
+
+ return html
+}
+
+const extensionMap: Record = {
+ vue: 'markup',
+ html: 'markup',
+ md: 'markdown',
+ rb: 'ruby',
+ ts: 'typescript',
+ py: 'python',
+ sh: 'bash',
+ yml: 'yaml',
+ styl: 'stylus',
+ kt: 'kotlin',
+ rs: 'rust',
+ node: 'js',
+ asm: 'nasm',
+ s: 'nasm',
+ assembly: 'nasm',
+ masm: 'nasm',
+ bat: 'batch',
+ 'c++': 'cpp',
+}
+
+function getLangCodeFromExtension (extension: string) {
+ return extensionMap[extension] || extension
+}
+
+function highlight (str: string, lang: string, lineNumber: boolean) {
+ if (!lang) {
+ return escape(str)
+ }
+
+ lang = lang.toLowerCase()
+ const rawLang = lang
+
+ lang = getLangCodeFromExtension(lang)
+
+ if (prism.languages[lang]) {
+ const code = prism.highlight(str, prism.languages[lang], lang)
+ return wrap(code, rawLang, lineNumber)
+ } else {
+ logger.warn(`Syntax highlight for language "${lang}" is not supported.`)
+ }
+
+ return wrap(str, 'text', lineNumber)
+}
+
+export default {
+ name: 'markdown-code-highlight',
+ register: (ctx: Ctx) => {
+ addCustomStyles(ctx)
+ ctx.markdown.registerPlugin(md => {
+ md.options.highlight = (str, lang) => highlight(str, lang, true)
+ })
+
+ let supportedLanguages: string
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ if (!supportedLanguages) {
+ supportedLanguages = Object.keys(prism.languages).concat(Object.keys(extensionMap)).sort().join(',').replace('DFS,', '')
+ }
+
+ items.push({ language: 'markdown', label: '/ ``` Code', insertText: '```${1|' + supportedLanguages + '|}\n$2\n```\n', block: true })
+ })
+
+ const exportStyles = `
+ ${defaultStyle}
+ code[class*="language-"], pre[class*="language-"] {
+ text-shadow: none;
+ }
+ `
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node, options }) => {
+ if (node.tagName === 'TABLE' && node.dataset.lang) {
+ const code = node.parentElement
+ ?.parentElement
+ ?.querySelector('.p-mcc-copy-btn.copy-text')
+ ?.dataset
+ ?.text
+
+ if (code) {
+ if (options.highlightCode) {
+ if (options.inlineStyle || options.includeStyle) {
+ node.outerHTML = ctx.lib.juice(
+ highlight(code, node.dataset.lang, false),
+ { extraCss: exportStyles }
+ )
+ } else {
+ node.outerHTML = highlight(code, node.dataset.lang, false)
+ }
+ } else {
+ node.outerHTML = ctx.lib.lodash.escape(code)
+ }
+ }
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code-run.ts b/src/renderer/plugins/markdown-code-run.ts
new file mode 100644
index 000000000..df5c1558f
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-run.ts
@@ -0,0 +1,391 @@
+import { computed, customRef, defineComponent, getCurrentInstance, h, nextTick, onBeforeUnmount, ref, shallowRef, VNode, watch, watchEffect } from 'vue'
+import Markdown from 'markdown-it'
+import { escape, throttle } from 'lodash-es'
+import { Plugin } from '@fe/context'
+import { getActionHandler } from '@fe/core/action'
+import { DOM_CLASS_NAME, FLAG_DISABLE_XTERM } from '@fe/support/args'
+import { CtrlCmd, getKeyLabel, matchKeys } from '@fe/core/keybinding'
+import { useI18n } from '@fe/services/i18n'
+import { getLogger, md5, sleep } from '@fe/utils'
+import SvgIcon from '@fe/components/SvgIcon.vue'
+import { getAllRunners } from '@fe/services/runner'
+import { registerHook, removeHook } from '@fe/core/hook'
+import type { CodeRunner, RenderEnv } from '@fe/types'
+
+const cache: Record = {}
+
+const logger = getLogger('markdown-code-run')
+
+const RunCode = defineComponent({
+ name: 'run-code',
+ props: {
+ code: {
+ type: String,
+ default: ''
+ },
+ language: String,
+ firstLine: String,
+ },
+ setup (props) {
+ const { t } = useI18n()
+ const instance = getCurrentInstance()
+ const result = customRef((track, trigger) => {
+ const _trigger = throttle(trigger, 200, { leading: true, trailing: true })
+ return {
+ get: () => {
+ track()
+ return cache[hash.value] || ''
+ },
+ set: (val: string) => {
+ cache[hash.value] = val
+ _trigger()
+ }
+ }
+ })
+ const abortController = shallowRef()
+ const hash = computed(() => md5(props.language + props.code))
+ const runner = ref()
+ const resultRef = ref()
+ const status = computed(() => runner.value?.nonInterruptible ? 'idle' : (abortController.value ? 'running' : 'idle'))
+ const getTerminalCmd = computed(() => runner.value?.getTerminalCmd(props.language!, props.firstLine!))
+
+ let hasResult = false
+
+ let appendLog: ((type: 'html' | 'plain', res: string) => void) | undefined = (type, res) => {
+ if (type === 'plain') {
+ res = escape(res)
+ }
+
+ let value = result.value
+
+ if (hasResult) {
+ value += res
+ } else {
+ value = res
+ hasResult = true
+ }
+
+ if (value.length > 32 * 1024) {
+ value = '------Output too long, truncated to 32K------\n' + value.slice(-32 * 1024)
+ }
+
+ result.value = value
+ }
+
+ const abort = () => {
+ if (abortController.value && !abortController.value.signal.aborted) {
+ abortController.value.abort()
+ abortController.value = undefined
+ if (!hasResult) {
+ result.value = ''
+ }
+ }
+ }
+
+ const run = async () => {
+ if (status.value === 'running') {
+ abort()
+ return
+ }
+
+ const { code, language } = props
+
+ hasResult = false
+
+ if (!runner.value) {
+ result.value = "No runner found for language '" + language + "'"
+ return
+ }
+
+ result.value = t('code-run.running')
+ await sleep(0)
+
+ try {
+ if (abortController.value) {
+ abort()
+ }
+
+ abortController.value = new AbortController()
+
+ const res = await runner.value.run(language!, code, {
+ signal: abortController.value?.signal,
+ flusher: (type, value) => appendLog?.(type, value)
+ })
+
+ if (!res) {
+ return
+ }
+
+ const { type, value: val } = res
+
+ if (typeof val === 'string') {
+ appendLog?.(type, val)
+ return
+ }
+
+ // read stream
+ while (true) {
+ if (abortController.value && abortController.value.signal.aborted) {
+ break
+ }
+
+ const { done, value } = await val.read()
+ if (done) {
+ logger.debug('run code done >', value)
+ appendLog?.(type, value || '')
+ break
+ }
+
+ logger.debug('run code result >', value)
+
+ if (!appendLog) {
+ break
+ }
+
+ let valStr = value
+
+ if (typeof value !== 'string') {
+ try {
+ valStr = new TextDecoder().decode(value)
+ } catch {
+ valStr = String(value)
+ }
+ }
+
+ appendLog(type, valStr)
+ }
+ } catch (error: any) {
+ if (error.name !== 'AbortError') {
+ appendLog?.('plain', error.message)
+ }
+ } finally {
+ abort()
+ }
+ }
+
+ const runInXterm = (e: MouseEvent) => {
+ const cmd = runner.value?.getTerminalCmd(props.language!, props.firstLine!)
+
+ if (!cmd) {
+ return
+ }
+
+ getActionHandler('xterm.run')({
+ code: props.code,
+ start: cmd.start,
+ exit: matchKeys(e, [CtrlCmd]) ? undefined : cmd.exit,
+ })
+ }
+
+ const clearResult = () => {
+ result.value = ''
+ hasResult = false
+ delete cache[hash.value]
+ instance?.proxy?.$forceUpdate()
+ }
+
+ watch(() => props.code, () => {
+ result.value = ''
+ })
+
+ watch(() => result.value, () => {
+ if (resultRef.value) {
+ // scroll to bottom if near the bottom
+ if (resultRef.value.scrollHeight - resultRef.value.scrollTop - resultRef.value.clientHeight < 50) {
+ nextTick(() => {
+ resultRef.value?.scrollTo(0, resultRef.value.scrollHeight)
+ })
+ }
+ }
+ }, { flush: 'pre' })
+
+ const refreshRunner = () => {
+ runner.value = getAllRunners().find((runner) => runner.match(props.language!, props.firstLine!))
+ }
+
+ const selectRunResult = (e: MouseEvent) => {
+ e.preventDefault()
+ e.stopPropagation()
+ const target = e.currentTarget as HTMLElement
+
+ const selection = target.ownerDocument.defaultView!.getSelection()
+ const range = target.ownerDocument.createRange()
+ range.selectNodeContents(e.currentTarget as HTMLElement)
+ selection?.removeAllRanges()
+ selection?.addRange(range)
+ }
+
+ watchEffect(refreshRunner)
+ registerHook('CODE_RUNNER_CHANGE', refreshRunner)
+
+ onBeforeUnmount(() => {
+ appendLog = undefined
+ abort()
+ removeHook('CODE_RUNNER_CHANGE', refreshRunner)
+ })
+
+ return () => {
+ const runResult = result.value
+
+ return [
+ h('div', { class: `p-mcr-run-code-action ${DOM_CLASS_NAME.SKIP_EXPORT}` }, [
+ h('div', {
+ title: status.value !== 'running' ? t('code-run.run') : t('code-run.stop'),
+ class: 'p-mcr-run-btn' + (status.value === 'running' ? ' p-mcr-run-btn-stop' : ''),
+ onClick: run
+ }),
+ h('div', {
+ title: t('code-run.run-in-xterm-tips', getKeyLabel(CtrlCmd)),
+ class: 'p-mcr-run-xterm-btn skip-print',
+ hidden: !getTerminalCmd.value,
+ onClick: runInXterm
+ }),
+ ]),
+ h('div', { class: `p-mcr-run-code-result ${DOM_CLASS_NAME.SKIP_EXPORT}`, ref: resultRef }, h('output', { onDblclick: selectRunResult, key: runResult, innerHTML: runResult })),
+ h('div', { class: 'p-mcr-clear-btn-wrapper skip-print' }, h(
+ h(
+ 'div',
+ { class: 'p-mcr-clear-btn', style: { display: runResult ? 'flex' : 'none' }, title: t('code-run.clear'), onClick: clearResult },
+ h(SvgIcon, { name: 'times', style: 'pointer-events: none' })
+ ),
+ )),
+ ]
+ }
+ }
+})
+
+const RunPlugin = (md: Markdown) => {
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
+ const token = tokens[idx]
+
+ const code = token.content.trim()
+ const firstLine = code.split(/\n/)[0].trim()
+ if (!firstLine.includes('--run--') || !token.info || env.safeMode) {
+ return temp(tokens, idx, options, env, slf)
+ }
+
+ const codeNode: VNode = temp(tokens, idx, options, env, slf) as any
+
+ if (codeNode && Array.isArray(codeNode.children)) {
+ codeNode.children.push(h(RunCode, {
+ key: code,
+ code,
+ firstLine,
+ language: token.info,
+ }))
+ }
+
+ return codeNode as any
+ }
+}
+
+export default {
+ name: 'markdown-code-run',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .p-mcr-run-code-action {
+ position: sticky;
+ left: 0;
+ border-top: dashed 1px #888;
+ margin: 1em 0;
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-btn {
+ position: absolute;
+ top: -.6em;
+ height: 0;
+ width: 0;
+ border-left: .7em #b7b3b3 solid;
+ border-top: .6em #dddddd00 solid;
+ border-bottom: .6em #dddddd00 solid;
+ border-right: 0;
+ background: rgba(0, 0, 0, 0);
+ cursor: pointer;
+ outline: none;
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-btn.p-mcr-run-btn-stop {
+ border: .56em #b7b3b3 solid;
+ border-radius: 4px;
+ animation: p-mcr-run-btn-stop 1.5s infinite;
+ }
+
+ @keyframes p-mcr-run-btn-stop {
+ 0% { border-color: #b7b3b3; }
+ 50% { border-color: #b7c3f3; }
+ 100% { border-color: #b7b3b3; }
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-xterm-btn {
+ position: absolute;
+ top: -.5em;
+ right: -0;
+ height: 0;
+ width: 0;
+ border-left: .7em #b7b3b3 solid;
+ border-top: .6em #dddddd00 solid;
+ border-bottom: .6em #dddddd00 solid;
+ border-right: 0;
+ background: rgba(0, 0, 0, 0);
+ cursor: pointer;
+ outline: none;transform: rotate(90deg);
+ }
+
+ .markdown-view .markdown-body .p-mcr-clear-btn-wrapper {
+ width: 0;
+ height: 0;
+ position: sticky;
+ left: 100%;
+ bottom: 0;
+ float: right;
+ }
+
+ .markdown-view .markdown-body .p-mcr-run-code-result {
+ position: sticky;
+ left: 0;
+ padding: .5em 0 0 0;
+ max-width: 100%;
+ max-height: 300px;
+ overflow: auto;
+ }
+
+ .markdown-view .markdown-body .p-mcr-clear-btn {
+ width: 20px;
+ height: 20px;
+ position: relative;
+ right: 12px;
+ bottom: 10px;
+ padding: 6px;
+ border-radius: 50%;
+ transition: opacity 200ms;
+ display: flex;
+ align-items: center;
+ color: var(--g-color-20);
+ background: var(--g-color-86);
+ }
+
+ .markdown-view .markdown-body .p-mcr-clear-btn:hover {
+ background: var(--g-color-76);
+ }
+ `, true)
+
+ ctx.markdown.registerPlugin(RunPlugin)
+
+ !FLAG_DISABLE_XTERM && ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
+ editor.addAction({
+ id: 'plugin.editor.run-in-xterm',
+ label: ctx.i18n.t('code-run.run-in-xterm'),
+ contextMenuGroupId: 'other',
+ precondition: 'editorHasSelection',
+ keybindingContext: 'editorHasSelection',
+ keybindings: [
+ monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KeyR
+ ],
+ run: () => {
+ getActionHandler('xterm.run')(editor.getModel()!.getValueInRange(editor.getSelection()!))
+ }
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code-wrap.ts b/src/renderer/plugins/markdown-code-wrap.ts
new file mode 100644
index 000000000..87cb35a97
--- /dev/null
+++ b/src/renderer/plugins/markdown-code-wrap.ts
@@ -0,0 +1,41 @@
+import type { Plugin } from '@fe/context'
+import type { FrontMatterAttrs, RenderEnv } from '@fe/types'
+
+export default {
+ name: 'markdown-code-wrap',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .${ctx.args.DOM_CLASS_NAME.WRAP_CODE},
+ .markdown-view .markdown-body .${ctx.args.DOM_CLASS_NAME.WRAP_CODE} ~ .p-mcr-run-code-result {
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ }
+
+ .markdown-view .markdown-body pre > code.${ctx.args.DOM_CLASS_NAME.AVOID_PAGE_BREAK} {
+ page-break-inside: avoid;
+ display: block;
+ }
+
+ @media print {
+ .markdown-view .markdown-body pre > code,
+ .markdown-view .markdown-body .p-mcr-run-code-result {
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ }
+ }
+ `)
+
+ ctx.markdown.registerPlugin(md => {
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
+ const attrs: FrontMatterAttrs = env.attributes!
+ if (attrs.wrapCode) {
+ const token = tokens[idx]
+ token.attrJoin('class', ctx.args.DOM_CLASS_NAME.WRAP_CODE)
+ }
+
+ return temp(tokens, idx, options, env, slf)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-code.ts b/src/renderer/plugins/markdown-code.ts
deleted file mode 100644
index e922936e7..000000000
--- a/src/renderer/plugins/markdown-code.ts
+++ /dev/null
@@ -1,226 +0,0 @@
-import Highlight from 'highlight.js'
-import { getKeyLabel } from '@fe/context/shortcut'
-import { Plugin, Ctx } from '@fe/context/plugin'
-import { getLogger } from '@fe/utils'
-
-const logger = getLogger('markdown-code')
-
-Highlight.registerAliases('node', { languageName: 'javascript' })
-
-/* eslint-disable */
-
-// https://github.com/wcoder/highlightjs-line-numbers.js
-
-const TABLE_NAME = 'hljs-ln'
-const LINE_NAME = 'hljs-ln-line'
-const CODE_BLOCK_NAME = 'hljs-ln-code'
-const NUMBERS_BLOCK_NAME = 'hljs-ln-numbers'
-const NUMBER_LINE_NAME = 'hljs-ln-n'
-const DATA_ATTR_NAME = 'data-line-number'
-const BREAK_LINE_REGEXP = /\r\n|\r|\n/g
-
-function addCustomStyles (ctx: Ctx) {
- ctx.theme.addStyles(
- `
- .markdown-view .markdown-body table.${TABLE_NAME},
- .markdown-view .markdown-body table.${TABLE_NAME} tr,
- .markdown-view .markdown-body table.${TABLE_NAME} td {
- border: 0;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} {
- padding-bottom: 10px;
- border-collapse: collaps;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} td {
- padding: 0;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} tbody {
- display: table;
- min-width: 100%;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} td.${NUMBERS_BLOCK_NAME} {
- -webkit-touch-callout: none;
- -webkit-user-select: none;
- -khtml-user-select: none;
- -moz-user-select: none;
- -ms-user-select: none;
- user-select: none;
- text-align: center;
- border-right: 1px solid #777;
- vertical-align: top;
- padding-right: 5px;
- max-width: 45px; width: 35px;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} td.${CODE_BLOCK_NAME} {
- padding-left: 10px;
- }
-
- .markdown-view .markdown-body table.${TABLE_NAME} .${NUMBER_LINE_NAME}:before{
- content: attr(${DATA_ATTR_NAME})
- }
-
- @media print {
- .markdown-view .markdown-body table.${TABLE_NAME} td {
- white-space: pre-wrap;
- }
- }
-
- @media screen {
- .markdown-view .markdown-body table.${TABLE_NAME} {
- max-height: 400px;
- }
- }
- `
- )
-}
-
-function lineNumbersInternal (element: any, options?: any) {
- // define options or set default
- options = options || {
- singleLine: false
- }
-
- // convert options
- var firstLineIndex = options.singleLine ? 0 : 1
-
- duplicateMultilineNodes(element)
-
- return addLineNumbersBlockFor(element.innerHTML, firstLineIndex)
-}
-
-function addLineNumbersBlockFor (inputHtml: any, firstLineIndex: any) {
- var lines = getLines(inputHtml)
-
- // if last line contains only carriage return remove it
- if (lines[lines.length - 1].trim() === '') {
- lines.pop()
- }
-
- if (lines.length > firstLineIndex) {
- var html = ''
-
- for (var i = 0, l = lines.length; i < l; i++) {
- html += format(
- '' +
- '' +
- '' +
- ' ' +
- '' +
- ' ' +
- ' ',
- [
- NUMBERS_BLOCK_NAME,
- LINE_NAME,
- NUMBER_LINE_NAME,
- DATA_ATTR_NAME,
- CODE_BLOCK_NAME,
- i + 1,
- lines[i].length > 0 ? lines[i] : ' '
- ])
- }
-
- return format('{1}
', [ TABLE_NAME, html ])
- }
-
- return inputHtml
-}
-
-/**
- * Recursive method for fix multi-line elements implementation in highlight.js
- * Doing deep passage on child nodes.
- * @param {HTMLElement} element
- */
-function duplicateMultilineNodes (element: any) {
- var nodes = element.childNodes
- for (var node in nodes) {
- if (nodes.hasOwnProperty(node)) {
- var child = nodes[node]
- if (getLinesCount(child.textContent) > 0) {
- if (child.childNodes.length > 0) {
- duplicateMultilineNodes(child)
- } else {
- duplicateMultilineNode(child.parentNode)
- }
- }
- }
- }
-}
-
-/**
- * Method for fix multi-line elements implementation in highlight.js
- * @param {HTMLElement} element
- */
-function duplicateMultilineNode (element: any) {
- var className = element.className
-
- if (!/hljs-/.test(className)) return
-
- var lines = getLines(element.innerHTML)
-
- for (var i = 0, result = ''; i < lines.length; i++) {
- var lineText = lines[i].length > 0 ? lines[i] : ' '
- result += format('{1}\n', [ className, lineText ])
- }
-
- element.innerHTML = result.trim()
-}
-
-function getLines (text: string) {
- if (text.length === 0) return []
- return text.split(BREAK_LINE_REGEXP)
-}
-
-function getLinesCount (text: string) {
- return (text.trim().match(BREAK_LINE_REGEXP) || []).length
-}
-
-/**
- * {@link https://wcoder.github.io/notes/string-format-for-string-formating-in-javascript}
- * @param {string} format
- * @param {array} args
- */
-function format (format: string, args: any) {
- return format.replace(/\{(\d+)\}/g, function (m, n) {
- return args[n] ? args[n] : m
- })
-}
-
-function highlight (str: string, lang: string) {
- if (lang && Highlight.getLanguage(lang)) {
- try {
- const element = document.createElement('code')
- element.innerHTML = Highlight.highlight(lang, str).value
- return lineNumbersInternal(element)
- } catch (error) {
- logger.error(error)
- }
- }
-
- return ''
-}
-
-export default {
- name: 'markdown-code',
- register: (ctx: Ctx) => {
- addCustomStyles(ctx)
- ctx.markdown.registerPlugin(md => {
- const Fun = (fn: Function) => (tokens: any, idx: any, options: any, env: any, slf: any) => {
- if (tokens[idx].attrIndex('title') < 0) {
- tokens[idx].attrJoin('class', 'copy-inner-text')
- tokens[idx].attrPush(['title', getKeyLabel('CtrlCmd') + ' + 单击复制'])
- }
-
- return (fn)(tokens, idx, options, env, slf)
- }
-
- md.renderer.rules.code_inline = Fun(md.renderer.rules.code_inline!.bind(md.renderer.rules))
- md.options.highlight = highlight as any
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-container.ts b/src/renderer/plugins/markdown-container.ts
new file mode 100644
index 000000000..d97138d1f
--- /dev/null
+++ b/src/renderer/plugins/markdown-container.ts
@@ -0,0 +1,385 @@
+import MarkdownItContainer from 'markdown-it-container'
+import { applyAttrs, getAttrs, parseInfo } from 'markdown-it-attributes'
+import { Fragment, h } from 'vue'
+import type Token from 'markdown-it/lib/token'
+import { Plugin } from '@fe/context'
+
+export default {
+ name: 'markdown-container',
+ register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .custom-container.section {
+ padding: 12px;
+ border: 1px solid var(--g-color-80);
+ border-radius: var(--g-border-radius);
+ margin-top: 16px;
+ position: relative;
+ }
+
+ .markdown-view .markdown-body .custom-container.section > :first-child {
+ margin-top: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.row {
+ display: flex;
+ justify-content: space-between;
+ position: relative;
+ margin-top: 16px;
+ }
+
+ .markdown-view .markdown-body .custom-container.row.has-title {
+ border-top: 24px solid transparent;
+ }
+
+ .markdown-view .markdown-body .custom-container.row > .custom-container-title {
+ background: var(--g-color-80);
+ position: absolute;
+ padding-left: 8px;
+ margin: 0;
+ font-size: 14px;
+ line-height: 2.2em;
+ left: 0;
+ top: -2.2em;
+ width: 100%;
+ border: 1px solid var(--g-color-80);
+ border-top-left-radius: var(--g-border-radius);
+ border-top-right-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.row > .custom-container.col > .custom-container-title {
+ font-size: 14px;
+ line-height: 1.2;
+ }
+
+ .markdown-view .markdown-body .custom-container.col {
+ width: 100%;
+ padding: 12px;
+ padding-bottom: 0;
+ border: 1px solid var(--g-color-80);
+ border-radius: var(--g-border-radius);
+ margin-right: 8px;
+ background: var(--g-color-100);
+ }
+
+ .markdown-view .markdown-body .custom-container.row.has-title > .custom-container.col {
+ margin-right: -1px;
+ border-radius: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.col:last-of-type,
+ .markdown-view .markdown-body .custom-container.row.has-title > .custom-container.col:last-of-type {
+ margin-right: 0;
+ border-bottom-right-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.row.has-title > .custom-container.col:first-of-type {
+ border-bottom-left-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.details,
+ .markdown-view .markdown-body .custom-container.danger,
+ .markdown-view .markdown-body .custom-container.warning,
+ .markdown-view .markdown-body .custom-container.tip {
+ padding: 2px 16px;
+ padding-top: 16px;
+ margin: 16px 0;
+ border-left-width: 8px;
+ border-left-style: solid;
+ border-radius: var(--g-border-radius);
+ }
+
+ .markdown-view .markdown-body .custom-container.danger,
+ .markdown-view .markdown-body .custom-container.warning,
+ .markdown-view .markdown-body .custom-container.tip {
+ page-break-inside: avoid;
+ }
+
+ .markdown-view .markdown-body .custom-container-title {
+ font-weight: 600;
+ margin-bottom: 10px;
+ margin-top: -6px;
+ font-size: 1.1em;
+ }
+
+ .markdown-view .markdown-body .custom-container.danger {
+ border-color: #cc0000;
+ background-color: #ffe0e0;
+ color: #660000;
+ }
+
+ .markdown-view .markdown-body .custom-container.warning {
+ border-color: #e7c000;
+ background-color: #fffae3;
+ color: #746000;
+ }
+
+ .markdown-view .markdown-body .custom-container.tip {
+ border-color: #42b983;
+ background-color: var(--g-color-90);
+ color: var(--g-color-10);
+ }
+
+ .markdown-view .markdown-body .custom-container.details {
+ border: none;
+ background-color: var(--g-color-90);
+ padding: 16px 20px;
+ }
+
+ .markdown-view .markdown-body .custom-container.details > summary {
+ margin-top: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.details > summary + *,
+ .markdown-view .markdown-body .custom-container.details > :first-child:not(summary) {
+ margin-top: 16px;
+ }
+
+ .markdown-view .markdown-body .custom-container.details > :last-child:not(summary) {
+ margin-bottom: 0;
+ }
+
+ .markdown-view .markdown-body .custom-container.group {
+ position: relative;
+ display: flex;
+ flex-wrap: wrap;
+ margin-bottom: 16px;
+ background: var(--g-color-80);
+ border-radius: var(--g-border-radius);
+ border: 1px solid var(--g-color-80);
+ }
+
+ .markdown-view .markdown-body .custom-container.group p {
+ order: 100;
+ width: 100%;
+ }
+
+ .markdown-view .markdown-body .custom-container.group > .custom-container-title {
+ order: 1;
+ padding-left: 8px;
+ margin: 0;
+ font-size: 14px;
+ line-height: 2.2em;
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-radio {
+ display: none;
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-label {
+ order: 1;
+ cursor: pointer;
+ font-size: 14px;
+ line-height: 2;
+ padding: 0 1em;
+ color: var(--g-color-20);
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-label:hover {
+ background: var(--g-color-85);
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-content {
+ order: 2;
+ width: 100%;
+ display: none;
+ border-radius: var(--g-border-radius);
+ border-top-left-radius: 0;
+ padding: 12px;
+ padding-bottom: 0;
+ background: var(--g-color-100);
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-radio:checked + .group-item-label {
+ background: var(--g-color-100);
+ border-top-left-radius: var(--g-border-radius);
+ border-top-right-radius: var(--g-border-radius);
+ color: var(--g-color-0);
+ font-weight: 500;
+ }
+
+ .markdown-view .markdown-body .custom-container.group .group-item-radio:checked + .group-item-label + .group-item-content {
+ display: block;
+ }
+
+ @media screen {
+ html[app-theme=dark] .markdown-view .markdown-body .custom-container.danger {
+ background-color: #503f3f;
+ color: #d9bebe;
+ }
+
+ html[app-theme=dark] .markdown-view .markdown-body .custom-container.warning {
+ background-color: #4a4738;
+ color: #cbb759;
+ }
+ }
+
+ @media (prefers-color-scheme: dark) {
+ html[app-theme=system] .markdown-view .markdown-body .custom-container.danger {
+ background-color: #503f3f;
+ color: #d9bebe;
+ }
+
+ html[app-theme=system] .markdown-view .markdown-body .custom-container.warning {
+ background-color: #4a4738;
+ color: #cbb759;
+ }
+ }
+ `)
+
+ let groupItemIdx = 0
+ let groupItemSeq = 0
+ let groupItemBase = Date.now()
+ let groupItemName = groupItemBase + groupItemSeq
+ const groupItemContentClass = 'group-item-content'
+
+ ctx.registerHook('MARKDOWN_BEFORE_RENDER', ({ env }) => {
+ // first render, reset count
+ if (env.renderCount === 0) {
+ groupItemBase = Date.now()
+ }
+
+ groupItemSeq = 0
+ })
+
+ function buildGroupItem (token: Token, title: string, attrs?: Record) {
+ const parent = h('div', attrs || Object.fromEntries(token.attrs || []), [])
+ const radioName = `group-item-${groupItemName}`
+ const id = `group-item-${groupItemName}-${groupItemIdx++}`
+ const checked = groupItemIdx === 1 || title.startsWith('*')
+
+ return {
+ node: h(Fragment, [
+ h('input', { key: id, class: 'group-item-radio', id, name: radioName, type: 'radio', 'data-default-checked': checked, checked }),
+ h('label', { class: 'group-item-label', for: id }, title.replace('*', '').trim() || 'Group Item'),
+ parent
+ ]),
+ parent
+ }
+ }
+
+ ctx.markdown.registerPlugin(md => {
+ ['tip', 'warning', 'danger', 'details', 'group-item', 'group', 'row', 'col', 'section', 'div', 'code-group'].forEach(name => {
+ const reg = new RegExp(`^${name}\\s*(.*)$`)
+
+ md.use(MarkdownItContainer, name, {
+ validate: (params: string) => {
+ return reg.test(params.trim())
+ },
+ render: function (tokens: Token[], idx: number) {
+ const token = tokens[idx]
+
+ if (token.nesting === 1) {
+ // TODO: get options
+ const attrsOpts = { leftDelimiter: '{', rightDelimiter: '}', allowedAttributes: undefined }
+
+ // apply attributes
+ const attrInfo = parseInfo(attrsOpts, token.info)
+ if (attrInfo) {
+ const attrs = getAttrs(attrInfo.exp)
+ token.info = attrInfo.text
+ applyAttrs(attrsOpts, token, attrs)
+ }
+
+ const match = token.info.trim().match(reg)
+ const title = md.utils.escapeHtml(match![1])
+ const isGroup = name === 'group' || name === 'code-group'
+
+ const containerClass = isGroup ? 'custom-container group' : `custom-container ${name}`
+
+ if (name === 'group-item') {
+ token.attrJoin('class', groupItemContentClass)
+ return buildGroupItem(token, title)
+ } else if (isGroup) {
+ groupItemIdx = 0
+ groupItemSeq++
+ groupItemName = groupItemBase + groupItemSeq
+ }
+
+ const containerTag = { details: 'details', section: 'section' }[name] || 'div'
+ const titleTag = name === 'details' ? 'summary' : 'p'
+ const titleClass = name === 'details' ? '' : 'custom-container-title'
+
+ const children = (title || isGroup) ? [h(titleTag, { class: titleClass }, title)] : []
+
+ token.attrJoin('class', containerClass)
+ if (title) {
+ token.attrJoin('class', 'has-title')
+ }
+
+ const props: Record = Object.fromEntries(token.attrs || [])
+
+ if (isGroup) {
+ props.key = groupItemName
+ }
+
+ if (name === 'code-group') {
+ for (
+ let i = idx + 1;
+ !(
+ tokens[i].nesting === -1 &&
+ tokens[i].type === 'container_code-group_close'
+ );
+ ++i
+ ) {
+ const token = tokens[i]
+ if (token.type === 'fence' && token.tag === 'code') {
+ if (!token.meta) {
+ token.meta = {}
+ }
+
+ token.meta.isCodeGroupItem = true
+ }
+ }
+ }
+
+ return h(containerTag, props, children)
+ }
+ }
+ })
+ })
+
+ const renderFence = md.renderer.rules.fence!
+ const infoTitleReg = /\[([^\]]*)\]/
+
+ md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ const token = tokens[idx]
+ if (token.meta && token.meta.isCodeGroupItem) {
+ const title = token.info.match(infoTitleReg)?.[1] || token.info || 'txt'
+ token.info = token.info.replace(infoTitleReg, '').trim()
+
+ const groupItem = buildGroupItem(token, title, { class: groupItemContentClass })
+ ;(groupItem.parent.children as any[]).push(
+ renderFence.call(slf, tokens, idx, options, env, slf)
+ )
+
+ return groupItem.node as any
+ }
+
+ return renderFence.call(slf, tokens, idx, options, env, slf)
+ }
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node }) => {
+ if (node.classList.contains('group-item-radio') && node.dataset.defaultChecked === 'true') {
+ node.setAttribute('checked', 'checked')
+ }
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ::: Container', insertText: '${3|:::,::::,:::::|} ${1|tip,warning,danger,details,code-group,group,group-item,row,col,section,div|} ${2:Title}\n${4:Content}\n${3|:::,::::,:::::|}\n', block: true, surroundSelection: '${4:Content}' },
+ { language: 'markdown', label: '/ ::: Group Container', insertText: ':::: group ${1:Title}\n::: group-item Tab 1\ntest 1\n:::\n::: group-item *Tab 2\ntest 2\n:::\n::: group-item Tab 3\ntest 3\n:::\n::::\n', block: true },
+ { language: 'markdown', label: '/ ::: Code Group Container', insertText: '::: code-group ${1:Title}\n${2:```js [test.js]\nlet a = 1\n```\n\n```ts [test.ts]\nlet a: number = 1\n```}\n:::\n', block: true },
+ { language: 'markdown', label: '/ ::: Column Container', insertText: ':::: row ${1:Title}\n::: col\ntest 1\n:::\n::: col\ntest 2\n:::\n::::\n', block: true },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/^:{3,}.*$/, 'tag']
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-drawio.ts b/src/renderer/plugins/markdown-drawio.ts
index 063bb1bab..7ac85ff74 100644
--- a/src/renderer/plugins/markdown-drawio.ts
+++ b/src/renderer/plugins/markdown-drawio.ts
@@ -1,89 +1,52 @@
import Markdown from 'markdown-it'
-import { defineComponent, h, ref, watch } from 'vue'
-import { Plugin } from '@fe/context/plugin'
-import { buildSrc, IFrame } from '@fe/context/embed'
-import * as api from '@fe/support/api'
-import { useBus } from '@fe/support/bus'
-import env from '@fe/utils/env'
-
-const Drawio = defineComponent({
- name: 'drawio',
- props: {
- url: String,
- content: String
- },
- setup (props) {
- const bus = useBus()
- const srcdoc = ref('')
- const iframe = ref()
-
- watch(props, async () => {
- srcdoc.value = await buildSrcdoc({ url: props.url, content: props.content || '' })
- }, { immediate: true })
-
- const resize = () => {
- iframe.value!.contentDocument!.body.style.height = 'auto'
- iframe.value!.contentDocument!.documentElement.style.height = 'auto'
- iframe.value!.height = iframe.value!.contentDocument!.documentElement.offsetHeight + 'px'
- iframe.value!.contentDocument!.body.style.height = iframe.value!.contentDocument!.body.clientHeight + 'px'
- iframe.value!.contentDocument!.documentElement.style.height = '100%'
- bus.emit('global.resize')
+import { h } from 'vue'
+import { Plugin } from '@fe/context'
+import { t } from '@fe/services/i18n'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+
+const MarkdownItPlugin = (md: Markdown) => {
+ const extensionId = '@yank-note/extension-drawio'
+
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
+
+ const render = () => {
+ if (!getInitialized()) {
+ return null
}
- const button = (text: string, onClick: any) => h('button', {
- style: 'margin-left: 5px;font-size: 14px;background: #cacaca; border: 0; padding: 0 6px; color: #2c2b2b; cursor: pointer; border-radius: 2px; transition: all .1s ease-in-out; line-height: 24px;',
- onClick
- }, text)
-
- return () => h('div', { class: 'drawio-wrapper reduce-brightness', style: 'position: relative' }, [
- h(
- 'div',
- {
- class: 'no-print',
- style: 'position: absolute; right: 15px; top: 3px; z-index: 1;'
- },
- [
- button('适应高度', resize),
- button('新窗口打开', () => env.openWindow(buildSrc(srcdoc.value, '查看图形'))),
- ]
- ),
- h(IFrame, {
- html: srcdoc.value,
- onLoad (frame) {
- iframe.value = frame
- resize()
- },
- iframeProps: {
- class: 'drawio',
- height: '300px',
- },
- })
- ])
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'Drawio'))
+ ))
}
-})
-
-const MarkdownItPlugin = (md: Markdown) => {
- const render = ({ url, content }: any) => h(Drawio, { url, content })
const linkTemp = md.renderer.rules.link_open!.bind(md.renderer.rules)
md.renderer.rules.link_open = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return linkTemp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
if (token.attrGet('link-type') !== 'drawio') {
return linkTemp(tokens, idx, options, env, slf)
}
- const url = token.attrGet('href')
const nextToken = tokens[idx + 1]
if (nextToken && nextToken.type === 'text') {
nextToken.content = ''
}
- return render({ url }) as any
+ return render() as any
}
const fenceTemp = md.renderer.rules.fence!.bind(md.renderer.rules)
md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return fenceTemp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
const code = token.content.trim()
@@ -92,92 +55,21 @@ const MarkdownItPlugin = (md: Markdown) => {
return fenceTemp(tokens, idx, options, env, slf)
}
- return render({ content: code }) as any
+ return render() as any
}
}
-type F = { repo?: string; path?: string; url?: string; content: string }
-
-async function buildSrcdoc ({ repo, path, content, url }: F) {
- if (url) {
- content = await (await fetch(url)).text()
- } else if (!content && repo && path) {
- content = (await api.readFile({ repo, path })).content
- }
-
- content = content.replace(//gs, '').trim()
-
- const div = document.createElement('div')
- div.className = 'mxgraph'
- div.dataset.mxgraph = JSON.stringify({
- highlight: '#00afff',
- lightbox: false,
- nav: true,
- resize: true,
- toolbar: 'pages zoom layers',
- page: 1,
- xml: content,
- })
-
- return `
-
- ${div.outerHTML}
-
- `
-}
-
export default {
name: 'markdown-drawio',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin)
- ctx.registerHook('ON_TREE_NODE_SELECT', async (item: any) => {
- if (item.path.toLowerCase().endsWith('.drawio')) {
- const srcdoc = await buildSrcdoc(item)
- env.openWindow(buildSrc(srcdoc, '查看图形'))
-
- return true
- }
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- return false
+ items.push(
+ { language: 'markdown', label: '/ []() Drawio Link', insertText: '[${2:Drawio}]($1){link-type="drawio"}', block: true },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-echarts.ts b/src/renderer/plugins/markdown-echarts.ts
index acd6df74b..d161322eb 100644
--- a/src/renderer/plugins/markdown-echarts.ts
+++ b/src/renderer/plugins/markdown-echarts.ts
@@ -1,114 +1,56 @@
import { h } from 'vue'
-import * as echarts from 'echarts'
-import CryptoJS from 'crypto-js'
-import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { getColorScheme } from '@fe/context/theme'
+import type Markdown from 'markdown-it'
+import type { Plugin } from '@fe/context'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+import { t } from '@fe/services/i18n'
+import { RenderEnv } from '@fe/types'
-const render = (code: string) => {
- const id = `echart-${CryptoJS.MD5(code).toString()}-${Math.random().toString(36).substr(2)}`
+const MarkdownItPlugin = (md: Markdown) => {
+ const extensionId = '@yank-note/extension-echarts'
- return h(
- 'div', { class: 'echarts', id, 'data-code': encodeURIComponent(code) })
-}
-
-const EChartsPlugin = (md: Markdown) => {
- const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
- md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
- const token = tokens[idx]
- const code = token.content.trim()
- if (token.info === 'js' && code.split(/\n/)[0].trim().includes('--echarts--')) {
- return render(code) as any
+ const render = () => {
+ if (!getInitialized()) {
+ return null
}
- return temp(tokens, idx, options, env, slf)
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'ECharts'))
+ ))
}
-}
-
-let charts: {[key: string]: any} = {}
-
-const update = (theme: string | undefined = undefined, animation: boolean | undefined = undefined, renderImg = false) => {
- theme ??= getColorScheme()
-
- Object.values(charts).forEach(x => x.chart.dispose())
- charts = {}
-
- for (const ele of document.getElementsByClassName('echarts')) {
- const el = ele as HTMLDivElement
- try {
- const id = el.getAttribute('id')!
- const code = el.dataset.code
-
- if (code) {
- const chart = echarts.init(el, theme)
- // eslint-disable-next-line
- eval(`(${decodeURIComponent(code)})(chart)`)
-
- if (animation !== undefined) {
- chart.setOption({ animation })
- }
-
- let img = null
- if (renderImg) {
- img = new Image()
- img.width = el.clientWidth
- img.height = el.clientHeight
- img.src = chart.getDataURL({})
- }
-
- charts[id] = { chart, img }
- }
- } catch (error) {
- el.innerText = error
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env: RenderEnv, slf) => {
+ if (checkExtensionLoaded() || env.safeMode) {
+ return temp(tokens, idx, options, env, slf)
}
- }
-}
-const preparePrint = () => {
- update('light', false, true)
+ const token = tokens[idx]
- for (const ele of document.getElementsByClassName('echarts')) {
- while (ele.firstChild) {
- ele.firstChild.remove()
+ const code = token.content.trim()
+ const firstLine = code.split(/\n/)[0].trim()
+ if (token.info !== 'js' || !firstLine.includes('--echarts--')) {
+ return temp(tokens, idx, options, env, slf)
}
- const id = ele.getAttribute('id')!
-
- if (charts[id] && charts[id].img) {
- ele.appendChild(charts[id].img)
- }
+ return render() as any
}
}
-window.addEventListener('resize', () => {
- Object.values(charts).forEach(x => x.chart.resize())
-})
-
-window.addEventListener('beforeprint', () => {
- update('light', false)
-})
-
export default {
name: 'markdown-echarts',
register: ctx => {
- ctx.theme.addStyles(`
- .markdown-view .markdown-body .echarts {
- width: 100%;
- height: 350px;
- }
- `)
+ ctx.markdown.registerPlugin(MarkdownItPlugin)
- ctx.markdown.registerPlugin(EChartsPlugin)
- ctx.registerHook('ON_VIEW_RENDERED', () => {
- update()
- })
- ctx.registerHook('ON_VIEW_BEFORE_CONVERT', () => {
- preparePrint() // 转换成图片形式，设置主题
- setTimeout(() => update(), 0) // 恢复
- })
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- ctx.bus.on('theme.change', () => update())
+ items.push(
+ { language: 'markdown', label: '/ ``` ECharts', insertText: '```js\n// --echarts-- \nconst option = {\n xAxis: {\n type: "category",\n data: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]\n },\n yAxis: {\n type: "value"\n },\n series: [\n {\n data: [150, 230, 224, 218, 135, 147, 260],\n type: "line"\n }\n ]\n}\n\nchart.setOption(option, true)\n```\n', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-footnote.ts b/src/renderer/plugins/markdown-footnote.ts
index f6e009f53..aee4c50dd 100644
--- a/src/renderer/plugins/markdown-footnote.ts
+++ b/src/renderer/plugins/markdown-footnote.ts
@@ -6,7 +6,7 @@
// https://github.com/markdown-it/markdown-it-footnote/blob/master/index.js
import { createVNode, Fragment } from 'vue'
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
// Process footnotes
//
@@ -131,7 +131,7 @@ function footnote_plugin (md) {
state.env.footnotes.refs[':' + label] = -1
token = new state.Token('footnote_reference_open', '', 1)
- token.meta = { label: label }
+ token.meta = { label }
token.level = state.level++
state.tokens.push(token)
@@ -225,7 +225,7 @@ function footnote_plugin (md) {
state.env.footnotes.list[footnoteId] = {
content: state.src.slice(labelStart, labelEnd),
- tokens: tokens
+ tokens
}
}
@@ -271,7 +271,7 @@ function footnote_plugin (md) {
if (state.env.footnotes.refs[':' + label] < 0) {
footnoteId = state.env.footnotes.list.length
- state.env.footnotes.list[footnoteId] = { label: label, count: 0 }
+ state.env.footnotes.list[footnoteId] = { label, count: 0 }
state.env.footnotes.refs[':' + label] = footnoteId
} else {
footnoteId = state.env.footnotes.refs[':' + label]
@@ -281,7 +281,7 @@ function footnote_plugin (md) {
state.env.footnotes.list[footnoteId].count++
token = state.push('footnote_ref', '', 0)
- token.meta = { id: footnoteId, subId: footnoteSubId, label: label }
+ token.meta = { id: footnoteId, subId: footnoteSubId, label }
}
state.pos = pos
@@ -379,6 +379,13 @@ function footnote_plugin (md) {
export default {
name: 'markdown-footnote',
register: ctx => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .footnote-backref {
+ padding: 0 4px;
+ font-family: system-ui;
+ vertical-align: middle;
+ }
+ `)
ctx.markdown.registerPlugin(footnote_plugin)
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-front-matter/index.ts b/src/renderer/plugins/markdown-front-matter/index.ts
new file mode 100644
index 000000000..e70bdc187
--- /dev/null
+++ b/src/renderer/plugins/markdown-front-matter/index.ts
@@ -0,0 +1,51 @@
+import type { Options } from 'markdown-it'
+import type { Plugin } from '@fe/context'
+import { processFrontMatter, useMarkdownItRule } from './lib'
+import workerIndexerUrl from './worker-indexer?worker&url'
+
+export default {
+ name: 'markdown-front-matter',
+ register: ctx => {
+ const logger = ctx.utils.getLogger('markdown-front-matter')
+ ctx.markdown.registerPlugin(md => {
+ const render = md.render
+
+ md.render = (src: string, env: any) => {
+ const { attributes } = processFrontMatter(src, env)
+ logger.debug('render', attributes)
+
+ // save origin options
+ const originOptions = { ...md.options }
+
+ // set options
+ if (attributes.mdOptions && typeof attributes.mdOptions === 'object') {
+ Object.assign(md.options, attributes.mdOptions)
+ }
+
+ const result = render.call(md, src, env)
+
+ // clear md.options
+ Object.keys(md.options).forEach(key => {
+ delete md.options[key as keyof Options]
+ })
+
+ // restore origin options
+ Object.assign(md.options, originOptions)
+
+ return result
+ }
+
+ useMarkdownItRule(md)
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ --- Front Matter', insertText: '---\nheadingNumber: true\nwrapCode: true\nenableMacro: true\nmdOptions: { linkify: true, breaks: true }\ndefine:\n APP_NAME: Yank Note\n---\n', block: true },
+ )
+ })
+
+ ctx.indexer.importScriptsToWorker(new URL(workerIndexerUrl, import.meta.url))
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-front-matter/lib.ts b/src/renderer/plugins/markdown-front-matter/lib.ts
new file mode 100644
index 000000000..298009f90
--- /dev/null
+++ b/src/renderer/plugins/markdown-front-matter/lib.ts
@@ -0,0 +1,46 @@
+import frontMatter from 'front-matter'
+import type MarkdownIt from 'markdown-it'
+
+export function processFrontMatter (src: string, env: any) {
+ let bodyBegin = 0
+ let attributes: Record = {}
+ try {
+ const fm = frontMatter(src)
+
+ bodyBegin = fm.bodyBegin - 1
+ if (fm.attributes && typeof fm.attributes === 'object') {
+ attributes = fm.attributes
+ }
+ } catch (error) {
+ console.error(error)
+ }
+
+ let count = 0
+ let bodyBeginPos = 0
+ while (count < bodyBegin) {
+ count++
+ bodyBeginPos = src.indexOf('\n', bodyBeginPos + 1)
+ }
+
+ Object.assign(env, { bodyBegin, bodyBeginPos, attributes, _front_matter_exec_flag: false })
+
+ return { attributes }
+}
+
+export function useMarkdownItRule (md: MarkdownIt) {
+ const firstRule = (md.block.ruler as any).__rules__[0]
+ md.block.ruler.before(firstRule.name, 'front-matter', (state, startLine) => {
+ if (state.env?._front_matter_exec_flag) {
+ return false
+ }
+
+ const bodyBegin = state.env?.bodyBegin || 0
+ if (startLine >= bodyBegin) {
+ return false
+ }
+
+ state.line = bodyBegin
+ state.env._front_matter_exec_flag = true
+ return true
+ })
+}
diff --git a/src/renderer/plugins/markdown-front-matter/worker-indexer.ts b/src/renderer/plugins/markdown-front-matter/worker-indexer.ts
new file mode 100644
index 000000000..c6bdf7cf9
--- /dev/null
+++ b/src/renderer/plugins/markdown-front-matter/worker-indexer.ts
@@ -0,0 +1,14 @@
+import { processFrontMatter, useMarkdownItRule } from './lib'
+import type { IndexerWorkerCtx } from '@fe/others/indexer-worker'
+
+const ctx: IndexerWorkerCtx = self.ctx
+
+ctx.markdown.use(md => {
+ const parse = md.parse
+ md.parse = (src: string, env: any) => {
+ processFrontMatter(src, env)
+ return parse.call(md, src, env)
+ }
+
+ useMarkdownItRule(md)
+})
diff --git a/src/renderer/plugins/markdown-github-alerts.ts b/src/renderer/plugins/markdown-github-alerts.ts
new file mode 100644
index 000000000..4c3201b91
--- /dev/null
+++ b/src/renderer/plugins/markdown-github-alerts.ts
@@ -0,0 +1,49 @@
+import MarkdownItGithubAlerts from 'markdown-it-github-alerts'
+import baseCss from 'markdown-it-github-alerts/styles/github-base.css?inline'
+import lightCss from 'markdown-it-github-alerts/styles/github-colors-light.css?inline'
+import darkCss from 'markdown-it-github-alerts/styles/github-colors-dark-class.css?inline'
+
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'markdown-github-alerts',
+ register: ctx => {
+ ctx.markdown.markdown.use(md => {
+ MarkdownItGithubAlerts(md, { matchCaseSensitive: false })
+ md.renderer.rules.alert_open = function (tokens, idx) {
+ const { title, type, icon } = tokens[idx].meta
+ return ctx.lib.vue.h('div', { class: `markdown-alert markdown-alert-${type}` }, [
+ ctx.lib.vue.h('p', { class: 'markdown-alert-title' }, [
+ ctx.lib.vue.h('span', { class: 'markdown-alert-icon', innerHTML: icon }),
+ title
+ ])
+ ]) as any
+ }
+ })
+
+ const darkVars = (darkCss as unknown as string).replace('.dark', '')
+ ctx.view.addStyles(`
+ ${baseCss}
+ ${lightCss}
+ @media screen { html[app-theme=dark] ${darkVars} }
+ @media (prefers-color-scheme: dark) { html[app-theme=system] ${darkVars} }
+
+ .markdown-alert {
+ avoid-break-inside: avoid;
+ }
+ `)
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+ items.push(
+ {
+ language: 'markdown',
+ label: '/ > Github Alerts',
+ insertText: '> [!${1|NOTE,TIP,IMPORTANT,WARNING,CAUTION|}]${2}\n> ${3:Content}\n',
+ block: true,
+ surroundSelection: (snippet, selection, model) => snippet.replace('> ${3:Content}', model.getValueInRange(selection).replaceAll(/^/gm, '> ')),
+ },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-heading-number.ts b/src/renderer/plugins/markdown-heading-number.ts
new file mode 100644
index 000000000..f78755fc5
--- /dev/null
+++ b/src/renderer/plugins/markdown-heading-number.ts
@@ -0,0 +1,115 @@
+import type { Plugin } from '@fe/context'
+import type { FrontMatterAttrs } from '@fe/types'
+
+export default {
+ name: 'markdown-heading-number',
+ register: ctx => {
+ ctx.theme.addStyles(`
+ .outline-toc {
+ counter-reset: outline-h2counter outline-h3counter outline-h4counter outline-h5counter outline-h6counter;
+ }
+
+ .outline-toc .tag-h1.show-number { counter-set: outline-h2counter; }
+ .outline-toc .tag-h2.show-number { counter-set: outline-h3counter; }
+ .outline-toc .tag-h3.show-number { counter-set: outline-h4counter; }
+ .outline-toc .tag-h4.show-number { counter-set: outline-h5counter; }
+ .outline-toc .tag-h5.show-number { counter-set: outline-h6counter; }
+
+ .outline-toc .tag-h2.show-number:before {
+ counter-increment: outline-h2counter;
+ content: counter(outline-h2counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h3.show-number:before {
+ counter-increment: outline-h3counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h4.show-number:before {
+ counter-increment: outline-h4counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) "."
+ counter(outline-h4counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h5.show-number:before {
+ counter-increment: outline-h5counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) "."
+ counter(outline-h4counter) "."
+ counter(outline-h5counter) ".\\0000a0\\0000a0";
+ }
+
+ .outline-toc .tag-h6.show-number:before {
+ counter-increment: outline-h6counter;
+ content: counter(outline-h2counter) "."
+ counter(outline-h3counter) "."
+ counter(outline-h4counter) "."
+ counter(outline-h5counter) "."
+ counter(outline-h6counter) ".\\0000a0\\0000a0";
+ }
+ `)
+
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body {
+ counter-reset: h2counter h3counter h4counter h5counter h6counter;
+ }
+
+ .markdown-view .markdown-body h1.show-number { counter-set: h2counter; }
+ .markdown-view .markdown-body h2.show-number { counter-set: h3counter; }
+ .markdown-view .markdown-body h3.show-number { counter-set: h4counter; }
+ .markdown-view .markdown-body h4.show-number { counter-set: h5counter; }
+ .markdown-view .markdown-body h5.show-number { counter-set: h6counter; }
+
+ .markdown-view .markdown-body h2.show-number:before {
+ counter-increment: h2counter;
+ content: counter(h2counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h3.show-number:before {
+ counter-increment: h3counter;
+ content: counter(h2counter) "."
+ counter(h3counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h4.show-number:before {
+ counter-increment: h4counter;
+ content: counter(h2counter) "."
+ counter(h3counter) "."
+ counter(h4counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h5.show-number:before {
+ counter-increment: h5counter;
+ content: counter(h2counter) "."
+ counter(h3counter) "."
+ counter(h4counter) "."
+ counter(h5counter) ".\\0000a0\\0000a0";
+ }
+
+ .markdown-view .markdown-body h6.show-number:before {
+ counter-increment: h6counter;
+ content: counter(h2counter) "."
+ counter(h3counter) "."
+ counter(h4counter) "."
+ counter(h5counter) "."
+ counter(h6counter) ".\\0000a0\\0000a0";
+ }
+ `)
+
+ ctx.markdown.registerPlugin(md => {
+ const headingOpen = md.renderer.rules.heading_open!
+
+ md.renderer.rules.heading_open = function (tokens, idx, opt, env, slf) {
+ const attrs: FrontMatterAttrs = env.attributes
+ if (attrs.headingNumber) {
+ const token = tokens[idx]
+ token.attrJoin('class', 'show-number')
+ }
+
+ return headingOpen.call(this, tokens, idx, opt, env, slf)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-html.ts b/src/renderer/plugins/markdown-html.ts
index c98f8a57b..c28320885 100644
--- a/src/renderer/plugins/markdown-html.ts
+++ b/src/renderer/plugins/markdown-html.ts
@@ -1,9 +1,10 @@
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
import StateBlock from 'markdown-it/lib/rules_block/state_block'
import StateInline from 'markdown-it/lib/rules_inline/state_inline'
import Token from 'markdown-it/lib/token'
import ParserInline from 'markdown-it/lib/parser_inline'
import MarkdownIt from 'markdown-it'
+import { RenderEnv } from '@fe/types'
const unquoted = '[^"\'=<>`\\x00-\\x20]+'
const singleQuoted = "'[^']*'"
@@ -16,69 +17,112 @@ const attribute = '(?:\\s+' + attrName + '(?:\\s*=\\s*' + attrValue + ')?)'
const selfCloseTag = '<(?:area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\b'
const openTag = '<([A-Za-z][A-Za-z0-9\\-]*)' + attribute + '*\\s*\\/?>'
const closeTag = '<\\/([A-Za-z][A-Za-z0-9\\-]*)\\s*>'
-const comment = '|'
+const comment = '(?:)'
-const HTML_TAG_RE = new RegExp('^(?:' + openTag + '|' + closeTag + '|' + comment + ')')
+const HTML_TAG_RE = new RegExp('^(?:' + comment + '|' + openTag + '|' + closeTag + ')')
const HTML_SELF_CLOSE_TAG_RE = new RegExp('^' + selfCloseTag, 'i')
+const INVALID_HTML_TAG_NAME_RE = /script/i
+const INVALID_ATTR_NAME_RE = /^on|^xmlns$|^xml$|^aria-|^srcdoc$/i
+const MULTI_LINE_TAG_RE = /^[^<]*<[A-Za-z][A-Za-z0-9]{0,20}[^>]*$/
+
+const SAFE_MODE_ALLOWED_TAGS = [
+ 'br', 'b', 'i', 'strong', 'em', 'a', 'pre', 'code', 'img',
+ 'tt', 'div', 'ins', 'del', 'sup', 'sub', 'p', 'ol', 'ul',
+ 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'h7', 'h8',
+ 'table', 'thead', 'tbody', 'tfoot', 'blockquote', 'dl', 'dt', 'dd', 'kbd',
+ 'q', 'samp', 'var', 'hr', 'ruby', 'rt', 'rp', 'li', 'tr', 'td', 'th', 's',
+ 'strike', 'summary', 'details', 'caption', 'figure', 'figcaption', 'abbr', 'bdo', 'cite',
+ 'dfn', 'mark', 'small', 'span', 'time', 'wbr',
+]
function isLetter (ch: number) {
const lc = ch | 0x20 // to lower case
return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)
}
-function htmlInline (state: StateInline): boolean {
+function setAttrs (token: Token, content: string) {
+ const div = document.createElement('template')
+ div.innerHTML = content
+
+ const element = div.content.firstElementChild
+ if (!element) {
+ return
+ }
+
+ const attrs: [string, any][] = []
+ for (let i = 0; i < element.attributes.length; i++) {
+ const attr = element.attributes[i]
+
+ if (validateAttrName(attr.name)) {
+ attrs.push([attr.name, attr.value])
+ }
+
+ token.attrs = attrs
+ }
+}
+
+function validateTagName (name: string) {
+ return !INVALID_HTML_TAG_NAME_RE.test(name)
+}
+
+function validateAttrName (name: string) {
+ return !INVALID_ATTR_NAME_RE.test(name.trim())
+}
+
+function htmlInline (state: StateInline, silent = false): boolean {
+ if (silent) { return false }
+
const pos = state.pos
if (!state.md.options.html) { return false }
- // Check start
const max = state.posMax
- if (state.src.charCodeAt(pos) !== 0x3C/* < */ || pos + 2 >= max) {
+
+ // Check start
+ let ch = state.src.charCodeAt(pos)
+ if (pos + 2 >= max || (ch !== 0x3C/* < */ && ch !== 0x2D/* - */)) {
return false
}
// Quick fail on second char
- const ch = state.src.charCodeAt(pos + 1)
- if (ch !== 0x21/* ! */ && ch !== 0x3F/* ? */ && ch !== 0x2F/* / */ && !isLetter(ch)) {
+ ch = state.src.charCodeAt(pos + 1)
+ if (ch !== 0x2D/* - */ && ch !== 0x21/* ! */ && ch !== 0x3F/* ? */ && ch !== 0x2F/* / */ && !isLetter(ch)) {
return false
}
const match = state.src.slice(pos).match(HTML_TAG_RE)
if (!match) { return false }
- const content = state.src.slice(pos, pos + match[0].length)
-
- // ignore comment
- if (content.startsWith('', pos)
+ if (idx < 0) {
+ return false
+ } else {
+ state.pos = idx + 3
+ return true
}
}
const prevHtmlTags = (state.md as any)._prev_inline_html_tags
let token: Token
- if (content.startsWith('')) {
+ if (!validateTagName(tag)) {
+ return false
+ }
+
const prevHtmlTag = prevHtmlTags.pop()
+
if (prevHtmlTags && prevHtmlTag === tag) {
token = state.push('html_close', tag, -1)
} else {
@@ -86,19 +130,52 @@ function htmlInline (state: StateInline): boolean {
return false
}
} else if (content.endsWith('/>') || HTML_SELF_CLOSE_TAG_RE.test(content)) {
+ if (!validateTagName(tag)) {
+ return false
+ }
+
token = state.push('html_self', tag, 0)
} else {
+ if (!validateTagName(tag)) {
+ return false
+ }
+
token = state.push('html_open', tag, 1)
prevHtmlTags.push(tag)
}
token.content = content
- setAttrs(token)
+ setAttrs(token, content)
state.pos += match[0].length
return true
}
+function getMultiLineTag (args: {lineText: string, line: number, endLine: number, state: StateBlock, pos: number}) {
+ let { lineText, line, endLine, state, pos } = args
+
+ let currentLine = lineText
+
+ do {
+ // don't allow empty line
+ if (currentLine.length === 0 || state.sCount[line] < state.blkIndent) {
+ return false
+ }
+
+ if (currentLine.includes('>')) {
+ lineText = state.src.slice(pos, state.eMarks[line])
+ return { lineText, line }
+ }
+
+ line++
+ if (line >= endLine) {
+ return false
+ }
+
+ currentLine = state.src.slice(state.bMarks[line], state.eMarks[line])
+ } while (true)
+}
+
function htmlBlock (state: StateBlock, startLine: number, endLine: number) {
let nextLine; let lineText
let pos = state.bMarks[startLine] + state.tShift[startLine]
@@ -109,26 +186,67 @@ function htmlBlock (state: StateBlock, startLine: number, endLine: number) {
if (!state.md.options.html) { return false }
if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
+ lineText = state.src.slice(pos, max)
+ nextLine = startLine
+
+ // multi-line comment detected
+ if (lineText.startsWith('')) {
+ for (; nextLine < endLine; nextLine++) {
+ pos = state.bMarks[nextLine] + state.tShift[nextLine]
+ max = state.eMarks[nextLine]
+ lineText = state.src.slice(pos, max)
+
+ if (lineText.endsWith('-->')) {
+ nextLine++
+ const token = state.push('comment', '', 0)
+ token.hidden = true
+ token.map = [startLine, nextLine]
+ break
+ }
+ }
+
+ state.line = nextLine
+ return true
+ }
+
+ const multiLineTag = getMultiLineTag({ lineText, line: nextLine, endLine, state, pos })
+ if (multiLineTag) {
+ lineText = multiLineTag.lineText
+ nextLine = multiLineTag.line + 1
+ } else {
+ return false
+ }
+
const inlineParse: any = state.md.inline.parse.bind(state.md.inline)
const pushState = state.push
const prevHtmlTags = (state.md as any)._prev_block_html_tags
- lineText = state.src.slice(pos, max)
- // 调用行内解析规则
+ // invoke inline parse function
inlineParse(lineText, state.md, state.env, state.tokens, prevHtmlTags, pushState)
// If we are here - we detected HTML block.
- for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
+ for (; nextLine < endLine; nextLine++) {
if (state.sCount[nextLine] < state.blkIndent) { break }
pos = state.bMarks[nextLine] + state.tShift[nextLine]
max = state.eMarks[nextLine]
lineText = state.src.slice(pos, max)
+ // break if it's empty line when previous tag is empty or the empty line is flowing tag
if (lineText.length === 0) {
break
}
+ if (MULTI_LINE_TAG_RE.test(lineText)) {
+ const multiLineTag = getMultiLineTag({ lineText, line: nextLine, endLine, state, pos })
+ if (multiLineTag) {
+ lineText = multiLineTag.lineText
+ nextLine = multiLineTag.line
+ } else {
+ return false
+ }
+ }
+
inlineParse(lineText, state.md, state.env, state.tokens, prevHtmlTags, pushState)
}
@@ -143,12 +261,12 @@ function htmlBlock (state: StateBlock, startLine: number, endLine: number) {
}
function inlineParse (this: ParserInline, src: string, md: any, env: any, outTokens: Token[], prevHtmlTags: string[], htmlBlock: boolean) {
- // 每次解析 inline 时候，重置或者使用外部的 html 标签堆栈
+ // restore or use external tag stack every time.
md._prev_inline_html_tags = prevHtmlTags || []
const state = new this.State(src, md, env, outTokens)
- // 如果是 html block 规则调用的，这里 hack 一下，避免 delimiters 为 undefined
+ // hack avoid delimiters to be undefined when html block called.
if (htmlBlock) {
Object.defineProperty(state, 'delimiters', {
get () {
@@ -168,7 +286,7 @@ function inlineParse (this: ParserInline, src: string, md: any, env: any, outTok
}
function parse (this: any, src: string, env: any) {
- // 每次运行解析程序，设定一个 block html 标签栈，便于后续处理程序匹配标签
+ // create block html tag stack for flow up process
this._prev_block_html_tags = []
return MarkdownIt.prototype.parse.call(this, src, env)
}
diff --git a/src/renderer/plugins/markdown-imsize.ts b/src/renderer/plugins/markdown-imsize.ts
new file mode 100644
index 000000000..fbd9be3e3
--- /dev/null
+++ b/src/renderer/plugins/markdown-imsize.ts
@@ -0,0 +1,279 @@
+// https://github.com/tatsy/markdown-it-imsize/blob/master/lib/index.js
+/* eslint-disable no-mixed-operators */
+/* eslint-disable prefer-const */
+/* eslint-disable camelcase */
+/* eslint-disable @typescript-eslint/no-var-requires */
+// Process 
+// ^^^^^^^^ this size specification
+
+import { Plugin } from '@fe/context'
+
+'use strict'
+
+function parseNextNumber (str: any, pos: any, max: any) {
+ let code
+ let start = pos
+ let result = {
+ ok: false,
+ pos,
+ value: ''
+ }
+
+ code = str.charCodeAt(pos)
+
+ while (pos < max && (code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) || code === 0x25 /* % */) {
+ code = str.charCodeAt(++pos)
+ }
+
+ result.ok = true
+ result.pos = pos
+ result.value = str.slice(start, pos)
+
+ return result
+}
+
+function parseImageSize (str: any, pos: any, max: any) {
+ let code
+ let result = {
+ ok: false,
+ pos: 0,
+ width: '',
+ height: ''
+ }
+
+ if (pos >= max) { return result }
+
+ code = str.charCodeAt(pos)
+
+ if (code !== 0x3d /* = */) { return result }
+
+ pos++
+
+ // size must follow = without any white spaces as follows
+ // (1) =300x200
+ // (2) =300x
+ // (3) =x200
+ code = str.charCodeAt(pos)
+ if (code !== 0x78 /* x */ && (code < 0x30 || code > 0x39) /* [0-9] */) {
+ return result
+ }
+
+ // parse width
+ let resultW = parseNextNumber(str, pos, max)
+ pos = resultW.pos
+
+ // next charactor must be 'x'
+ code = str.charCodeAt(pos)
+ if (code !== 0x78 /* x */) { return result }
+
+ pos++
+
+ // parse height
+ let resultH = parseNextNumber(str, pos, max)
+ pos = resultH.pos
+
+ result.width = resultW.value
+ result.height = resultH.value
+ result.pos = pos
+ result.ok = true
+ return result
+}
+
+function image_with_size (md: any) {
+ return function (state: any, silent: any) {
+ let attrs
+ let code
+ let label
+ let labelEnd
+ let labelStart
+ let pos
+ let ref
+ let res
+ let title
+ let width = ''
+ let height = ''
+ let token
+ let tokens: any
+ let start
+ let href = ''
+ const oldPos = state.pos
+ const max = state.posMax
+
+ if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }
+ if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }
+
+ labelStart = state.pos + 2
+ labelEnd = md.helpers.parseLinkLabel(state, state.pos + 1, false)
+
+ // parser failed to find ']', so it's not a valid link
+ if (labelEnd < 0) { return false }
+
+ pos = labelEnd + 1
+ if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
+ //
+ // Inline link
+ //
+
+ // [link]( "title" )
+ // ^^ skipping these spaces
+ pos++
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+ if (pos >= max) { return false }
+
+ // [link]( "title" )
+ // ^^^^^^ parsing link destination
+ start = pos
+ res = md.helpers.parseLinkDestination(state.src, pos, state.posMax)
+ if (res.ok) {
+ href = state.md.normalizeLink(res.str)
+ if (state.md.validateLink(href)) {
+ pos = res.pos
+ } else {
+ href = ''
+ }
+ }
+
+ // [link]( "title" )
+ // ^^ skipping these spaces
+ start = pos
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+
+ // [link]( "title" )
+ // ^^^^^^^ parsing link title
+ res = md.helpers.parseLinkTitle(state.src, pos, state.posMax)
+ if (pos < max && start !== pos && res.ok) {
+ title = res.str
+ pos = res.pos
+
+ // [link]( "title" )
+ // ^^ skipping these spaces
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+ } else {
+ title = ''
+ }
+
+ // [link]( "title" =WxH )
+ // ^^^^ parsing image size
+ if (pos - 1 >= 0) {
+ code = state.src.charCodeAt(pos - 1)
+
+ // there must be at least one white spaces
+ // between previous field and the size
+ if (code === 0x20) {
+ res = parseImageSize(state.src, pos, state.posMax)
+ if (res.ok) {
+ width = res.width
+ height = res.height
+ pos = res.pos
+
+ // [link]( "title" =WxH )
+ // ^^ skipping these spaces
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+ }
+ }
+ }
+
+ if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
+ state.pos = oldPos
+ return false
+ }
+ pos++
+ } else {
+ //
+ // Link reference
+ //
+ if (typeof state.env.references === 'undefined') { return false }
+
+ // [foo] [bar]
+ // ^^ optional whitespace (can include newlines)
+ for (; pos < max; pos++) {
+ code = state.src.charCodeAt(pos)
+ if (code !== 0x20 && code !== 0x0A) { break }
+ }
+
+ if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
+ start = pos + 1
+ pos = md.helpers.parseLinkLabel(state, pos)
+ if (pos >= 0) {
+ label = state.src.slice(start, pos++)
+ } else {
+ pos = labelEnd + 1
+ }
+ } else {
+ pos = labelEnd + 1
+ }
+
+ // covers label === '' and label === undefined
+ // (collapsed reference link and shortcut reference link respectively)
+ if (!label) { label = state.src.slice(labelStart, labelEnd) }
+
+ ref = state.env.references[md.utils.normalizeReference(label)]
+ if (!ref) {
+ state.pos = oldPos
+ return false
+ }
+ href = ref.href
+ title = ref.title
+ }
+
+ //
+ // We found the end of the link, and know for a fact it's a valid link;
+ // so all that's left to do is to call tokenizer.
+ //
+ if (!silent) {
+ state.pos = labelStart
+ state.posMax = labelEnd
+
+ const newState = new state.md.inline.State(
+ state.src.slice(labelStart, labelEnd),
+ state.md,
+ state.env,
+ tokens = []
+ )
+ newState.md.inline.tokenize(newState)
+
+ token = state.push('image', 'img', 0)
+ token.attrs = attrs = [['src', href],
+ ['alt', '']]
+ token.children = tokens
+ if (title) {
+ attrs.push(['title', title])
+ }
+
+ if (width !== '') {
+ attrs.push(['width', width])
+ }
+
+ if (height !== '') {
+ attrs.push(['height', height])
+ }
+ }
+
+ state.pos = pos
+ state.posMax = max
+ return true
+ }
+}
+
+function imsize_plugin (md: any) {
+ md.inline.ruler.before('emphasis', 'image', image_with_size(md))
+}
+
+export default {
+ name: 'markdown-imsize',
+ register: ctx => {
+ ctx.markdown.registerPlugin(imsize_plugin)
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-katex.ts b/src/renderer/plugins/markdown-katex.ts
index 6f58ecbe4..b2a846d8d 100644
--- a/src/renderer/plugins/markdown-katex.ts
+++ b/src/renderer/plugins/markdown-katex.ts
@@ -13,8 +13,14 @@ for rendering output.
*/
import katex from 'katex'
+import 'katex/contrib/mhchem/mhchem.js'
import { h } from 'vue'
-import { Plugin } from '@fe/context/plugin'
+import type { Plugin } from '@fe/context'
+import type Token from 'markdown-it/lib/token'
+import styles from 'katex/dist/katex.min.css?inline'
+import monacoLatex from '@fe/others/monaco-latex'
+import { getRenderCache } from '@fe/services/renderer'
+import { triggerHook } from '@fe/core/hook'
// Test if potential opening or closing delimieter
// Assumes that there is a "$" at state.src[pos]
@@ -38,8 +44,8 @@ function isValidDelim (state: any, pos: number) {
}
return {
- can_open: can_open,
- can_close: can_close
+ can_open,
+ can_close
}
}
@@ -99,7 +105,7 @@ function math_inline (state: any, silent: boolean) {
token.markup = '$'
token.content = state.src.slice(start, match)
- // 如果本行字符串以 $ 结尾，避免 markdown-it-attrs 解析，插入一个空白节点
+ // if ends with `$`, insert empty node to avoid markdown-it-attrs parse
if (state.src.endsWith('$')) {
state.push('text', '', 0)
}
@@ -159,40 +165,62 @@ function math_block (state: any, start: number, end: number, silent: boolean) {
return true
}
-function math_plugin (md: any, options: any) {
- // Default options
+function renderToString (latex: string, options: any) {
+ const cacheKey = JSON.stringify(options) + latex
- options = options || {}
+ const innerHTML = getRenderCache('plugin-katex', cacheKey, () => {
+ const payload = { latex, options }
+ triggerHook('PLUGIN_HOOK', { plugin: 'markdown-katex', type: 'before-render', payload })
+ latex = payload.latex
+ options = payload.options
+
+ const html = katex.renderToString(latex, options)
+
+ // block
+ if (options.displayMode) {
+ return html
+ }
+
+ // inline
+ return html.replace(/^/, '')
+ .replace(/<\/span>$/, '')
+ })
+
+ return { cacheKey, innerHTML }
+}
+
+function math_plugin (md: any) {
// set KaTeX as the renderer for markdown-it-simplemath
- const katexInline = function (latex: any) {
- options.displayMode = false
+ const inlineRenderer = function (tokens: Token[], idx: number, _: any, env: any) {
+ const latex = tokens[idx].content
+
+ const { katex = {} } = env.attributes || {}
+ const options = Object.assign({ displayMode: false }, katex)
+
try {
- return katex.renderToString(latex, options)
- } catch (error) {
- if (options.throwOnError) { console.error(error) }
+ const { innerHTML, cacheKey } = renderToString(latex, options)
+ return h('span', { class: 'katex', key: idx + cacheKey, innerHTML })
+ } catch (error: any) {
return h('code', {}, `${error.message} [${latex}]`)
}
}
- const inlineRenderer = function (tokens: any, idx: any) {
- return katexInline(tokens[idx].content)
- }
+ const blockRenderer = function (tokens: Token[], idx: number, _: any, env: any) {
+ const token = tokens[idx]
+ const latex = token.content
+
+ const { katex = {} } = env.attributes || {}
+ const options = Object.assign({ displayMode: true }, katex)
- const katexBlock = function (latex: any) {
- options.displayMode = true
try {
- return 'cur : null
+}
+
+function handleLink (link: HTMLAnchorElement): boolean {
+ const currentFile = getRenderEnv()?.file || store.state.currentFile
+ if (!currentFile) {
+ return false
+ }
+
+ const href = link.getAttribute('href') || ''
+
+ if (!href.trim()) {
+ useToast().show('warning', 'Link is empty.')
+ return true
+ }
+
+ const _switchDoc = async (parsedLink: ParseLinkResult | null) => {
+ if (parsedLink?.type !== 'internal') {
+ ctx.ui.useToast().show('warning', 'Invalid File Path.')
+ return
+ }
+
+ const file: Doc = parsedLink.path
+ ? { path: parsedLink.path, type: 'file', name: parsedLink.name || basename(parsedLink.path), repo: currentFile.repo }
+ : currentFile
+
+ await ctx.doc.switchDoc(file, { source: 'markdown-link', position: parsedLink.position })
+ }
+
+ const isWikiLink = !!link.getAttribute(DOM_ATTR_NAME.WIKI_LINK)
+ if (!isWikiLink) {
+ const parsedLink = parseLink(currentFile, href, false)
+ if (parsedLink?.type === 'external') {
+ if (/^file:\/\//i.test(parsedLink?.href)) {
+ openPath(decodeURI(parsedLink.href.replace(/^file:\/\//i, '')))
+ return true
+ } else if (/javascript:/i.test(href)) {
+ return false
+ } else {
+ try {
+ if (isElectron) {
+ openExternal(link.href)
+ } else {
+ window.open(link.href)
+ }
+ } catch (error) {
+ console.error(error)
+ useToast().show('warning', 'Failed to open link')
+ }
+
+ return true
+ }
+ } else if (parsedLink?.type === 'internal') {
+ const openFile = () => {
+ const parsedLink = parseLink(currentFile, href, false)
+ const path = (parsedLink && 'path' in parsedLink) ? parsedLink.path : ''
+
+ if (!path) {
+ return true
+ }
+
+ let basePath = (getRepo(currentFile.repo)?.path || '/')
+
+ // net drive path start with '\\' on Windows, so we need to replace '/' to '\\' to prevent `join` lost the first part.
+ if (isWindows) {
+ basePath = basePath.replaceAll('/', '\\')
+ }
+
+ openPath(join(basePath, path))
+ }
+
+ if (link.classList.contains(DOM_CLASS_NAME.MARK_OPEN)) {
+ openFile()
+ return true
+ } else if (
+ (!parsedLink.path && parsedLink.position) || // anchor
+ isMarkdownFile(parsedLink.path) // markdown file
+ ) {
+ _switchDoc(parsedLink)
+ return true
+ } else {
+ const doc: Doc = { path: parsedLink.path, type: 'file', name: basename(parsedLink.path), repo: currentFile.repo }
+
+ getAvailableCustomEditors({ doc }).then(editors => {
+ if (editors.length > 0) {
+ _switchDoc(parsedLink)
+ } else {
+ openFile()
+ }
+ })
+
+ return true
+ }
+ } else {
+ useToast().show('warning', 'Invalid link.')
+ return true
+ }
+ } else {
+ // is Wiki Link
+ if (store.state.currentRepo?.name === currentFile.repo && store.state.tree) {
+ _switchDoc(parseLink(currentFile, href, true, store.state.tree))
+ } else {
+ fetchTree(currentFile.repo, { by: 'mtime', order: 'desc' }).catch(() => []).then(tree => {
+ const parsedLink = parseLink(currentFile, href, true, tree)
+ _switchDoc(parsedLink)
+ })
+ }
+
+ return true
+ }
+}
+
+function convertLink (state: StateCore) {
+ const currentFile = state.env.file || store.state.currentFile
+ return convertResourceState(currentFile, state, getAttachmentURL)
+}
+
+export default {
+ name: 'markdown-link',
+ register: (ctx) => {
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', async ({ node, options }) => {
+ // local image
+ const src = (node as any).src
+ if (src && node.getAttribute(DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ if (options.useRemoteSrcOfLocalImage) {
+ node.setAttribute('src', src)
+ return
+ }
+
+ if (options.inlineLocalImage || options.uploadLocalImage) {
+ try {
+ const originSrc = node.getAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ const res: Response = await ctx.api.fetchHttp(src)
+ const fileName = originSrc ? ctx.utils.path.basename(removeQuery(originSrc)) : 'img'
+ const file = new File(
+ [await res.blob()],
+ fileName,
+ { type: ctx.lib.mime.getType(fileName) || undefined }
+ )
+
+ let url: string | undefined
+ if (options.inlineLocalImage) {
+ url = await ctx.utils.fileToBase64URL(file)
+ } else if (options.uploadLocalImage) {
+ url = await ctx.action.getActionHandler('plugin.image-hosting-picgo.upload')(file)
+ }
+
+ if (url) {
+ node.setAttribute('src', url)
+ node.removeAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ }
+ } catch (error) {
+ console.log(error)
+ }
+ } else {
+ node.setAttribute('src', src)
+ }
+ }
+
+ const originSrc = node.getAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ if (originSrc) {
+ node.setAttribute('src', originSrc)
+ node.removeAttribute(DOM_ATTR_NAME.ORIGIN_SRC)
+ }
+ })
+
+ ctx.registerHook('VIEW_ELEMENT_CLICK', async ({ e }) => {
+ const anchorTarget = getAnchorElement(e.target)
+
+ if (anchorTarget) {
+ if (handleLink(anchorTarget)) {
+ e.preventDefault()
+ e.stopPropagation()
+ return true
+ } else {
+ return true
+ }
+ }
+
+ return false
+ })
+
+ ctx.registerHook('VIEW_AFTER_REFRESH', () => {
+ ctx.view.getRenderIframe().then(iframe => {
+ // reload all images
+ const images = iframe.contentDocument!.querySelectorAll('img')
+ for (let i = 0; i < images.length; i++) {
+ const img = images[i]
+
+ if (img.getAttribute(DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ if (img.src) {
+ // add timestamp to force reload
+ img.src = img.src.includes('?') ? `${img.src}&_t=${Date.now()}` : `${img.src}?_t=${Date.now()}`
+ }
+ }
+ }
+ })
+ })
+
+ ctx.registerHook('DOC_SWITCH_SKIPPED', ({ opts }) => {
+ if (opts?.position) {
+ ctx.routines.changePosition(opts.position)
+ }
+ })
+
+ ctx.registerHook('DOC_SWITCHED', ({ doc, opts }) => {
+ if (doc && opts?.position) {
+ ctx.routines.changePosition(opts.position)
+ }
+ })
+
+ ctx.markdown.registerPlugin(md => {
+ md.core.ruler.push('convert-relative-path', convertLink)
+ md.renderer.rules.link_open = (tokens, idx, options, _, slf) => {
+ if (tokens[idx].attrIndex('target') < 0) {
+ tokens[idx].attrPush(['target', '_blank'])
+ }
+
+ return slf.renderToken(tokens, idx, options)
+ }
+
+ // skip link validate
+ md.validateLink = () => true
+ })
+
+ ctx.view.tapContextMenus((menus, e) => {
+ const target = e.target as HTMLLinkElement
+ const parent = target.parentElement
+ const link = target.getAttribute('href') || ''
+ const text = target.innerText
+
+ if (
+ target.tagName === 'A' &&
+ parent?.dataset?.sourceLine &&
+ (text === link || text === decodeURI(link)) &&
+ /^http:\/\/|^https:\/\//.test(link)
+ ) {
+ menus.push({
+ id: 'plugin.markdown-link.transform-link',
+ type: 'normal',
+ label: ctx.i18n.t('markdown-link.convert-to-titled-link'),
+ onClick: async () => {
+ try {
+ ctx.ui.useToast().show('info', 'Loading……', 0)
+ const res = await ctx.api.proxyFetch(target.href, { timeout: 10000 }).then(r => r.text())
+ const match = res.match(/]*>([^<]*)<\/title>/si) || []
+ const title = ctx.lib.lodash.unescape(match[1] || '').trim()
+
+ if (!title) {
+ throw new Error('No title')
+ }
+
+ const lineStart = parseInt(parent.getAttribute(DOM_ATTR_NAME.SOURCE_LINE_START) || '0')
+ const lineEnd = parseInt(parent.getAttribute(DOM_ATTR_NAME.SOURCE_LINE_END) || '0') - 1
+
+ const content = ctx.editor.getLinesContent(lineStart, lineEnd)
+ .replace(new RegExp(`(??(?!\\))`, 'i'), `[${title}](${link})`)
+
+ ctx.editor.replaceLines(lineStart, lineEnd, content)
+ ctx.ui.useToast().hide()
+ } catch (error: any) {
+ console.error(error)
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ })
+ }
+ })
+
+ ctx.indexer.importScriptsToWorker(new URL(workerIndexerUrl, import.meta.url))
+
+ return { mdRuleConvertLink: convertLink, htmlHandleLink: handleLink }
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-link/lib.ts b/src/renderer/plugins/markdown-link/lib.ts
new file mode 100644
index 000000000..b7d5aa0a1
--- /dev/null
+++ b/src/renderer/plugins/markdown-link/lib.ts
@@ -0,0 +1,221 @@
+import { basename, dirname, normalizeSep, resolve } from '@fe/utils/path'
+import { isMarkdownFile, MARKDOWN_FILE_EXT } from '@share/misc'
+import { DOM_ATTR_NAME, RESOURCE_TAG_NAMES } from '@fe/support/args'
+import { triggerHook } from '@fe/core/hook'
+import { removeQuery } from '@fe/utils/pure'
+import { isWindows } from '@fe/support/env'
+import type { Token } from 'markdown-it'
+import type StateCore from 'markdown-it/lib/rules_core/state_core'
+import type { Components, Doc, ParseLinkResult, PathItem, PositionState, ResourceTagName } from '@fe/types'
+
+const RE_POS = /:([0-9]+),?([0-9]+)?$/
+const RE_EXTERNAL_LINK = /^[a-zA-Z_+-]{1,}:/
+const RE_VIDEO = /\.(mp4|webm|ogg)$/
+const RE_AUDIO = /\.(mp3|wav|ogg)$/
+const RE_EXTNAME = /^[a-zA-Z0-9_-]{1,10}$/
+
+export function isAnchorToken (token: Token) {
+ return token.tag === 'a'
+}
+
+export function isResourceToken (token: Token) {
+ return RESOURCE_TAG_NAMES.includes(token.tag as ResourceTagName)
+}
+
+export function normalizeExternalLink (link: string) {
+ if (link.startsWith('//')) {
+ return 'https:' + link
+ }
+
+ if (isWindows && /^[a-zA-Z]:[\\/].+/.test(link)) { // windows path
+ return 'file://' + link
+ }
+
+ return link
+}
+
+export function isDataUrl (url: string) {
+ return url.startsWith('data:')
+}
+
+const treeCache = new WeakMap>()
+
+export function getFirstMdMatchPath (tree: Components.Tree.Node[], dir: string, fileName: string): string | null {
+ if (fileName.includes('/')) {
+ return fileName
+ }
+
+ const inDirPath = dir.endsWith('/') ? (dir + fileName) : (dir + '/' + fileName)
+ let cache = treeCache.get(tree)
+
+ if (!cache) {
+ const buildCache = (cache: Map, items: Components.Tree.Node[]) => {
+ // BFS
+
+ const queue: Components.Tree.Node[] = [...items]
+ while (queue.length > 0) {
+ const item = queue.shift()
+ if (!item) continue
+
+ const p = item.path
+ if (item.type === 'file' && isMarkdownFile(p)) {
+ cache.set(p, true)
+
+ // cache the first match
+ if (!cache.has(item.name)) {
+ cache.set(item.name, p)
+ }
+ }
+
+ if (item.children) {
+ queue.push(...item.children)
+ }
+ }
+ }
+
+ cache = new Map()
+ buildCache(cache, tree)
+ treeCache.set(tree, cache)
+ }
+
+ if (cache.has(inDirPath)) { // find in dir
+ return inDirPath
+ } else { // find first match
+ const val = cache.get(fileName)
+ return typeof val === 'string' ? val : null
+ }
+}
+
+export function convertResourceState (currentFile: PathItem, state: StateCore, buildAttachmentUrl?: (file: Doc) => string) {
+ const { repo, path } = currentFile || {}
+ if (!repo || !path) {
+ throw new Error('currentFile is required')
+ }
+
+ const link = (token: Token) => {
+ const attrName = 'src'
+ let attrVal = decodeURIComponent(token.attrGet(attrName) || '')
+ if (!attrVal) {
+ return
+ }
+
+ attrVal = normalizeExternalLink(attrVal)
+
+ if (RE_EXTERNAL_LINK.test(attrVal)) { // external link
+ return
+ }
+
+ const basePath = dirname(path)
+
+ const originAttr = DOM_ATTR_NAME.ORIGIN_SRC
+ const originPath = removeQuery(attrVal).replace(RE_POS, '')
+ const filePath = resolve(basePath, originPath)
+ const fileName = basename(filePath)
+
+ const file: Doc = {
+ type: 'file',
+ repo,
+ path: filePath,
+ name: fileName,
+ }
+
+ if (RE_VIDEO.test(fileName)) {
+ token.tag = 'video'
+ token.type = 'media'
+ } else if (RE_AUDIO.test(fileName)) {
+ token.tag = 'audio'
+ token.type = 'media'
+ token.attrSet('preload', 'none')
+ } else {
+ token.attrSet(DOM_ATTR_NAME.LOCAL_IMAGE, 'true')
+ }
+
+ token.attrSet(DOM_ATTR_NAME.TARGET_PATH, filePath)
+ token.attrSet(DOM_ATTR_NAME.TARGET_REPO, repo)
+ token.attrSet(originAttr, attrVal)
+
+ if (buildAttachmentUrl) {
+ token.attrSet(attrName, buildAttachmentUrl(file))
+ }
+ }
+
+ const convert = (tokens: Token[]) => {
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i]
+ if (isResourceToken(token)) {
+ link(token)
+ }
+
+ if (token.children) {
+ convert(token.children)
+ }
+ }
+ }
+
+ convert(state.tokens)
+
+ return true
+}
+
+export function parseLink (currentFile: PathItem, href: string, isWikiLink: false): ParseLinkResult | null
+export function parseLink (currentFile: PathItem, href: string, isWikiLink: true, tree: Components.Tree.Node[]): ParseLinkResult | null
+export function parseLink (currentFile: PathItem, href: string, isWikiLink: boolean, tree?: Components.Tree.Node[]): ParseLinkResult | null {
+ if (!currentFile) {
+ return null
+ }
+
+ href = href.trim()
+
+ if (!href) {
+ return null
+ }
+
+ href = normalizeExternalLink(href)
+
+ if (RE_EXTERNAL_LINK.test(href)) {
+ return { type: 'external', href }
+ }
+
+ const tmp = decodeURI(href).split('#')
+
+ const parsePathPos = (path: string): {pos: [number, number] | null, path: string} => {
+ const match = path.match(RE_POS)
+ let pos: [number, number] | null = null
+ if (match) {
+ path = path.replace(RE_POS, '')
+ pos = [parseInt(match[1]), match[2] ? parseInt(match[2]) : 1]
+ }
+
+ return { pos, path }
+ }
+
+ let { path, pos } = parsePathPos(normalizeSep(tmp[0]))
+ const baseDir = dirname(currentFile.path)
+ path = path.trim()
+
+ if (path) {
+ if (isWikiLink && tree) {
+ path = path.replace(/:/g, '/') // replace all ':' to '/'
+
+ const lastDotPos = path.lastIndexOf('.')
+ const ext = lastDotPos > -1 ? path.slice(lastDotPos + 1) : ''
+ const fileName = RE_EXTNAME.test(ext) ? path : path += MARKDOWN_FILE_EXT
+
+ if (isMarkdownFile(fileName)) {
+ path = getFirstMdMatchPath(tree, baseDir, fileName) || path
+ }
+ }
+
+ path = resolve(baseDir, path)
+ }
+
+ const hash = tmp.slice(1).join('#')
+ const position: PositionState | null = pos ? { line: pos[0], column: pos[1] } : hash ? { anchor: hash } : null
+
+ const name = basename(path)
+ const result: ParseLinkResult = { type: 'internal', path, name, position }
+
+ triggerHook('AFTER_PARSE_LINK', { params: { currentFile, href, isWikiLink, tree }, result })
+
+ return result
+}
diff --git a/src/renderer/plugins/markdown-link/worker-indexer.ts b/src/renderer/plugins/markdown-link/worker-indexer.ts
new file mode 100644
index 000000000..d3af82aaf
--- /dev/null
+++ b/src/renderer/plugins/markdown-link/worker-indexer.ts
@@ -0,0 +1,15 @@
+import { convertResourceState } from './lib'
+import type { IndexerWorkerCtx } from '@fe/others/indexer-worker'
+import type StateCore from 'markdown-it/lib/rules_core/state_core'
+
+const ctx: IndexerWorkerCtx = self.ctx
+
+ctx.markdown.use(md => {
+ md.core.ruler.push('convert-relative-path', (state: StateCore) => {
+ const currentFile = state.env?.file
+ return convertResourceState(currentFile, state)
+ })
+
+ // skip link validate
+ md.validateLink = () => true
+})
diff --git a/src/renderer/plugins/markdown-luckysheet.ts b/src/renderer/plugins/markdown-luckysheet.ts
index 475b08210..7ee70ef8b 100644
--- a/src/renderer/plugins/markdown-luckysheet.ts
+++ b/src/renderer/plugins/markdown-luckysheet.ts
@@ -1,302 +1,33 @@
-import { defineComponent, h, ref, watch } from 'vue'
-
+import { h } from 'vue'
import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { getLogger } from '@fe/utils'
-import { Doc } from '@fe/support/types'
-import { useModal } from '@fe/support/modal'
-import { useToast } from '@fe/support/toast'
-import { dirname, join } from '@fe/utils/path'
-import env from '@fe/utils/env'
+import { Plugin } from '@fe/context'
import store from '@fe/support/store'
-import * as api from '@fe/support/api'
-import { refreshTree } from '@fe/context/tree'
-import { buildSrc, IFrame } from '@fe/context/embed'
-import Mask from '@fe/components/Mask.vue'
-
-const logger = getLogger('plugin-markdown-luckysheet')
-
-const fileExt = '.luckysheet'
-
-function buildSrcdoc (repo: string, path: string, full: boolean) {
- const options = { container: 'lucky-sheet', lang: 'zh', showtoolbarConfig: { print: false } }
- let onload = ''
-
- if (full) {
- onload = `
- const btn = document.createElement('button');
- btn.style = 'border: 0; background: #666; cursor: pointer; margin-left: 10px; color: #fff; padding: 4px 8px;';
- btn.innerText = '保存'
- btn.onclick = save
- document.querySelector('.luckysheet_info_detail .sheet-name').after(btn)
- document.querySelector('.luckysheet_info_detail .luckysheet_info_detail_update').innerText = '${path}'
- setStatus('加载完毕')
-
- ${env.isElectron
- ? `
- let closeWindow = false
- const remote = window.nodeRequire && window.nodeRequire('electron').remote
- window.onbeforeunload = evt => {
- if (saved() || closeWindow) return null
-
- if (!remote) {
- return true
- }
-
- evt.returnValue = true
-
- setTimeout(() => {
- let result = remote.dialog.showMessageBoxSync({
- type: 'question',
- cancelId: 1,
- message: '文档未保存，确定要关闭吗？',
- buttons: ['关闭', '取消']
- })
-
- if (result === 0) {
- closeWindow = true
- remote.getCurrentWindow().close()
- }
- })
- }` : 'window.onbeforeunload = () => saved() ? null : true'
- }
-
- window.addEventListener('keydown', e => {
- const isMacOS = /macintosh|mac os x/i.test(navigator.userAgent)
- const ctrl = isMacOS ? e.metaKey : e.ctrlKey
- if (ctrl && e.code === 'KeyS') {
- save()
- e.stopPropagation()
- e.preventDefault()
- }
- })
- `
- Object.assign(options, {})
- } else {
- Object.assign(options, {
- showtoolbar: false,
- showinfobar: false,
- allowEdit: false,
- showsheetbarConfig: {
- add: false,
- menu: false,
- sheet: true
- },
- sheetRightClickConfig: {
- delete: false,
- copy: false,
- rename: false,
- color: false,
- hide: false,
- move: false,
- },
- })
- }
-
- return `
-
-
-
-
-
-
-
-
-
- `
-}
-
-const LuckyComponent = defineComponent({
- name: 'lucky-sheet',
- props: {
- repo: String,
- path: String
- },
- setup (props) {
- logger.debug('setup', props)
- const srcdoc = ref('')
- const refIFrame = ref()
- const refFullIFrame = ref()
- const fullScreen = ref(false)
-
- const update = () => {
- srcdoc.value = buildSrcdoc(props.repo!, props.path!, false)
- }
-
- const reload = () => {
- refIFrame.value.reload()
- }
+const MarkdownItPlugin = (md: Markdown) => {
+ const extensionId = '@yank-note/extension-luckysheet'
- const open = () => {
- fullScreen.value = true
- }
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
- const close = async () => {
- try {
- refFullIFrame.value.close()
- fullScreen.value = false
- } catch {
- if (await useModal().confirm({ title: '未保存文件', content: '是否要关闭？' })) {
- fullScreen.value = false
- }
- }
+ const render = () => {
+ if (!getInitialized()) {
+ return null
}
- watch(props, update, { immediate: true })
-
- const button = (text: string, onClick: any) => h('button', {
- style: 'margin-left: 5px;font-size: 14px;background: #cacaca; border: 0; padding: 0 6px; color: #2c2b2b; cursor: pointer; border-radius: 2px; transition: all .1s ease-in-out; line-height: 24px;',
- onClick
- }, text)
-
- const buildIFrame = (full: boolean) => h(IFrame, {
- ref: full ? refFullIFrame : refIFrame,
- html: buildSrcdoc(props.repo!, props.path!, full),
- debounce: 1000,
- iframeProps: {
- class: 'lucky-sheet',
- style: 'margin: 0;display:block;height: ' + (full ? 'calc(100vh - 30px)' : '500px'),
- width: '100%'
- }
- })
-
- return () => [
- fullScreen.value && h(Mask, {
- show: true,
- maskCloseable: false,
- escCloseable: false,
- style: { paddingTop: '30px' }
- }, [
- h(
- 'div',
- {
- class: 'no-print',
- style: 'position: absolute; right: 15px; margin-top: 15px; z-index: 1;'
- },
- button('关闭', close),
- ),
- buildIFrame(true),
- ]),
-
- h('div', { class: 'lucky-sheet-wrapper reduce-brightness', style: 'position: relative' }, [
- h(
- 'div',
- {
- class: 'no-print',
- style: 'position: absolute; right: 15px; top: 3px; z-index: 1;'
- },
- [
- button('编辑', open),
- button('重载', reload),
- button('新窗口编辑', () => {
- const html = buildSrcdoc(props.repo!, props.path!, true)
- env.openWindow(buildSrc(html, '编辑表格', false), '_blank', { alwaysOnTop: false })
- }),
- ]
- ),
- buildIFrame(false)
- ])
- ]
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'Luckyseet'))
+ ))
}
-})
-const MarkdownItPlugin = (md: Markdown) => {
const linkTemp = md.renderer.rules.link_open!.bind(md.renderer.rules)
md.renderer.rules.link_open = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return linkTemp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
if (token.attrGet('link-type') !== 'luckysheet') {
@@ -308,102 +39,17 @@ const MarkdownItPlugin = (md: Markdown) => {
return linkTemp(tokens, idx, options, env, slf)
}
- const url = token.attrGet('origin-href')
+ const url = token.attrGet('href')
if (!url || url.includes(':')) {
return linkTemp(tokens, idx, options, env, slf)
}
- const path = join(dirname(currentFile.path), url)
-
const nextToken = tokens[idx + 1]
if (nextToken && nextToken.type === 'text') {
nextToken.content = ''
}
- return h(LuckyComponent, { repo: currentFile.repo, path }) as any
- }
-}
-
-async function createLuckysheet (node: Doc) {
- const currentPath = node.path
-
- let filename = await useModal().input({
- title: '创建 Luckysheet 文件',
- hint: '文件路径',
- content: '当前路径：' + currentPath,
- value: 'new-sheet' + fileExt,
- select: true
- })
-
- if (!filename) {
- return
- }
-
- if (!filename.endsWith(fileExt)) {
- filename = filename.replace(/\/$/, '') + fileExt
- }
-
- const path = join(currentPath, filename).replace(/^\//, '')
-
- if (!path) {
- throw new Error('需要传入文件路径')
- }
-
- const file: Doc = { repo: node.repo, path: path, type: 'file', name: '', contentHash: 'new' }
-
- if (typeof file.content !== 'string') {
- file.content = JSON.stringify([{
- name: 'Sheet1',
- color: '',
- status: 1,
- order: 0,
- data: Array(20).fill(Array(14).fill(null)),
- config: {
- merge: {},
- rowlen: {},
- rowhidden: {}
- },
- index: 0,
- jfgird_select_save: [],
- luckysheet_select_save: [{
- row: [0, 0],
- column: [0, 0],
- row_focus: 0,
- column_focus: 0,
- left: 0,
- width: 73,
- top: 0,
- height: 19,
- left_move: 0,
- width_move: 73,
- top_move: 0,
- height_move: 19
- }],
- visibledatarow: [],
- visibledatacolumn: [],
- ch_width: 4560,
- rh_height: 1760,
- luckysheet_selection_range: [],
- zoomRatio: 1,
- scrollLeft: 0,
- scrollTop: 0,
- calcChain: [],
- filter_select: null,
- filter: null,
- luckysheet_conditionformat_save: [],
- luckysheet_alternateformat_save: [],
- dataVerification: {},
- hyperlink: {},
- celldata: []
- }])
- }
-
- try {
- await api.writeFile(file, file.content)
- refreshTree()
- } catch (error) {
- useToast().show('warning', error.message)
- console.error(error)
+ return render() as any
}
}
@@ -411,31 +57,13 @@ export default {
name: 'markdown-luckysheet',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin)
- ctx.registerHook('ON_TREE_NODE_SELECT', async (item: Doc) => {
- if (item.path.toLowerCase().endsWith(fileExt)) {
- const srcdoc = buildSrcdoc(item.repo, item.path, true)
- env.openWindow(buildSrc(srcdoc, '编辑表格', false), '_blank', { alwaysOnTop: false })
-
- return true
- }
-
- return false
- })
- ctx.tree.registerContextMenu((items, node) => {
- if (node.type === 'dir') {
- items.push(
- { type: 'separator' },
- {
- id: 'create-luckysheet',
- type: 'normal',
- label: '创建 Luckysheet 文件',
- onClick: () => createLuckysheet(node)
- }
- )
- }
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- return items
+ items.push(
+ { language: 'markdown', label: '/ []() Luckysheet Link', insertText: '[${2:Luckysheet}]($1){link-type="luckysheet"}', block: true },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-macro.ts b/src/renderer/plugins/markdown-macro.ts
new file mode 100644
index 000000000..c6c0f3f79
--- /dev/null
+++ b/src/renderer/plugins/markdown-macro.ts
@@ -0,0 +1,494 @@
+import { escapeRegExp, merge, omit } from 'lodash-es'
+import frontMatter from 'front-matter'
+import type { Plugin } from '@fe/context'
+import type { BuildInSettings, Doc } from '@fe/types'
+import type { MenuItem } from '@fe/services/status-bar'
+import { render } from '@fe/services/view'
+import { t } from '@fe/services/i18n'
+import { readFile } from '@fe/support/api'
+import { getLogger, md5 } from '@fe/utils'
+import { basename, dirname, resolve } from '@fe/utils/path'
+import { getPurchased } from '@fe/others/premium'
+import { isPlain } from '@fe/services/document'
+import ctx from '@fe/context'
+
+type Result = { __macroResult: true, vars?: Record, value: string }
+type CacheItem = {
+ $include?: Record
+ $define: Record
+} & Record>
+
+const logger = getLogger('plugin-macro')
+const debounceToast = ctx.lib.lodash.debounce((...args: [any, any]) => ctx.ui.useToast().show(...args), 300)
+const magicNewline = '--yn-macro-new-line--'
+
+const AsyncFunction = Object.getPrototypeOf(async () => 0).constructor
+let globalMacroReplacement: Record = {}
+
+const globalVars = {
+ $export: exportVar,
+ $afterMacro: afterMacro,
+ $ctx: ctx,
+ $noop: noop,
+}
+
+function createSeq () {
+ const counters: Record = {}
+ return function (str = '') {
+ if (!counters[str]) {
+ counters[str] = 0
+ }
+ counters[str]++
+ return `${str}${counters[str]}`
+ }
+}
+
+function lineCount (str: string) {
+ let s = 1
+ const len = str.length
+
+ for (let i = 0; i < len; i++) {
+ if (str.charCodeAt(i) === 0x0A) {
+ s++
+ }
+ }
+
+ return s
+}
+
+function wrapResult (result: any) {
+ let value = result
+ let res = result
+ if (result.__macroResult) {
+ value = result.value
+ } else {
+ res = { __macroResult: true, value: '' + value }
+ }
+
+ if (
+ value === null ||
+ typeof value === 'function' ||
+ typeof value === 'symbol' ||
+ typeof value === 'undefined' ||
+ (typeof value === 'object')
+ ) {
+ throw new Error('Macro result type error.')
+ }
+
+ return res
+}
+
+function macro (exp: string, vars: Record): Result | Promise {
+ logger.debug('macro', exp)
+
+ exp = exp.replaceAll(magicNewline, '\n')
+
+ const FunctionConstructor = exp.startsWith('await') ? AsyncFunction : Function
+ const fun = new FunctionConstructor('vars', `with (vars) { return (${exp}); }`)
+
+ let result = fun(vars)
+
+ if (!(result instanceof Promise)) {
+ return wrapResult(result)
+ }
+
+ result = result.then(wrapResult)
+
+ return result
+}
+
+function transform (
+ src: string,
+ vars: Record,
+ options: {
+ autoRerender: boolean,
+ purchased: boolean,
+ cache: CacheItem,
+ callback?: (result: Result | Promise, match: string, matchPos: number) => void
+ },
+): { value: string, vars: Record } {
+ let _vars: Record = merge({ define: { ...globalMacroReplacement } }, vars)
+ const define = { ...options.cache.$define, ..._vars.define }
+ _vars.define = define
+ const keys = Object.keys(define)
+ if (keys.length) {
+ const reg = new RegExp(keys.filter(Boolean).map(escapeRegExp).join('|'), 'g')
+ src = src.replace(reg, match => {
+ const val = define[match]
+ // only support single line macro expression
+ if (typeof val === 'string' && /^\s*\[=.+?=\]\s*$/s.test(val)) {
+ // single line expression
+ return val.trim().replaceAll('\n', magicNewline)
+ } else {
+ match = match.replace(/\n|'/, '\\$&')
+ return `[= define['${match}'] =]`
+ }
+ })
+ }
+
+ const value = src.replace(/\[=.+?=\]/gs, (match, matchPos) => {
+ try {
+ const exp = match
+ .substring(2, match.length - 2)
+ .trim()
+ .replace(/=\\\]|\[\\=/g, x => x.replace('\\', ''))
+
+ const id = md5(exp)
+
+ let result: Result | Promise
+ if (options.purchased) {
+ if (options.cache[id]) {
+ result = options.cache[id]
+ } else {
+ result = macro(exp, _vars)
+ if (result instanceof Promise) {
+ options.cache[id] = result
+ .catch(() => ({ __macroResult: true, value: match } as Result))
+ .then(res => {
+ options.cache[id] = res
+ options.autoRerender && render()
+ return res
+ })
+ }
+ }
+ } else {
+ result = { __macroResult: true, value: t('premium.need-purchase', 'Macro') + `, ${t('premium.buy-license')} ` }
+ }
+
+ options.callback?.(result, match, matchPos)
+
+ if (result instanceof Promise) {
+ return 'running...'
+ }
+
+ if (result.vars) {
+ _vars = merge({}, result.vars, _vars)
+ }
+
+ return result.value
+ } catch {}
+
+ return match.replaceAll(magicNewline, '\n')
+ })
+
+ return { value, vars: _vars }
+}
+
+function exportVar (key: string, val: any): Result {
+ return { __macroResult: true, vars: { [key]: val }, value: '' }
+}
+
+function afterMacro (fn: (src: string) => string): Result {
+ return { __macroResult: true, vars: { $__hook_after_macro: fn }, value: '' }
+}
+
+// do nothing, text placeholder
+function noop () {
+ return { __macroResult: true, value: '' }
+}
+
+async function include (
+ options: {
+ belongDoc: Doc | undefined | null
+ purchased: boolean,
+ cache: CacheItem,
+ count: number,
+ vars: Record
+ },
+ path: string,
+ trim = false
+): Promise {
+ const { belongDoc } = options
+
+ if (!belongDoc) {
+ throw new Error('Current document is null')
+ }
+
+ if (options.count >= 3) {
+ return { __macroResult: true, value: 'Error: $include maximum call stack size exceeded [3]' }
+ }
+
+ if (!isPlain({ type: 'file', path })) {
+ return { __macroResult: true, value: 'Error: $include path is not a plain file' }
+ }
+
+ try {
+ const absolutePath = resolve(dirname(belongDoc.path), path)
+ const file: Doc = { type: 'file', name: basename(absolutePath), repo: belongDoc.repo, path: absolutePath }
+ const { content } = await readFile(file)
+ const fm = frontMatter(content)
+
+ // merge front-matter attributes to current document vars.
+ const vars: Record = merge(
+ {},
+ (fm.attributes && typeof fm.attributes === 'object') ? fm.attributes : {},
+ options.vars
+ )
+
+ vars.$include = include.bind(null, { ...options, belongDoc: file, count: options.count + 1, vars })
+ vars.$_doc = {
+ basename: file.name ? file.name.substring(0, file.name.lastIndexOf('.')) : '',
+ ...ctx.lib.lodash.pick(file, 'name', 'repo', 'path', 'content', 'status')
+ }
+
+ const cache = options.cache
+ if (options.count === 0 && !options.cache.$include) {
+ cache.$include = {}
+ }
+
+ const cacheKey = '' + options.count + file.repo + file.path
+ if (!cache.$include![cacheKey]) {
+ cache.$include![cacheKey] = { $define: {} } as CacheItem
+ }
+
+ const body = trim ? fm.body.trim() : fm.body
+
+ const tasks: Promise[] = []
+ let result = transform(
+ body,
+ vars,
+ {
+ ...options,
+ cache: cache.$include![cacheKey],
+ autoRerender: false,
+ callback: res => {
+ if (res instanceof Promise) {
+ tasks.push(res.then(x => {
+ cache.$include![cacheKey].$define = { ...x.vars?.define }
+ return x
+ }))
+ }
+ }
+ }
+ )
+
+ if (tasks.length > 0) {
+ await Promise.allSettled(tasks)
+
+ // get final result
+ result = transform(
+ body,
+ vars,
+ {
+ ...options,
+ cache: cache.$include![cacheKey],
+ autoRerender: false,
+ }
+ )
+ }
+
+ cache.$define = { ...result.vars.define }
+
+ return { __macroResult: true, vars: omit(result.vars, '$include', '$_doc'), value: result.value }
+ } catch (error: any) {
+ return error.message
+ }
+}
+
+function hookAfter (body: string, vars: Record) {
+ if (vars.$__hook_after_macro && typeof vars.$__hook_after_macro === 'function') {
+ try {
+ return vars.$__hook_after_macro(body)
+ } catch (error) {
+ debounceToast('warning', `[$afterMacro]: ${error}`)
+ return body
+ }
+ }
+
+ return body
+}
+
+export default {
+ name: 'markdown-macro',
+ register: ctx => {
+ ctx.markdown.registerPlugin(md => {
+ md.core.ruler.after('normalize', 'after_normalize', (state) => {
+ const env = state.env || {}
+ const file = env.file || {}
+
+ if (!env.attributes || !env.attributes.enableMacro || env.safeMode) {
+ return false
+ }
+
+ const cache = ctx.renderer.getRenderCache('plugin-macro', 'cache', { $define: {} } as CacheItem)
+
+ const options = {
+ purchased: getPurchased() || file.repo === ctx.args.HELP_REPO_NAME,
+ cache,
+ autoRerender: true,
+ }
+
+ const vars: Record = { ...globalVars, ...env.attributes }
+
+ vars.$include = include.bind(null, { ...options, belongDoc: file, count: 0, vars })
+ vars.$seq = createSeq()
+ vars.$doc = {
+ basename: file.name ? file.name.substring(0, file.name.lastIndexOf('.')) : '',
+ ...ctx.lib.lodash.pick(env.file, 'name', 'repo', 'path', 'content', 'status')
+ }
+
+ if (!env.macroLines) {
+ env.macroLines = []
+ }
+
+ let lineOffset = 0
+ let posOffset = 0
+
+ const bodyBeginPos = env.bodyBeginPos || 0
+ const head = state.src.substring(0, bodyBeginPos)
+ const body = state.src.substring(bodyBeginPos)
+
+ const result = transform(body, vars, {
+ ...options,
+ callback: (result, match, matchPos) => {
+ if (result instanceof Promise) {
+ return
+ }
+
+ const resultStr = result.value
+ const matchLine = lineCount(match)
+ const resultLine = lineCount(resultStr)
+
+ if (resultLine !== matchLine) {
+ const currentLineOffset = (matchLine - resultLine)
+ const currentPosOffset = (match.length - resultStr.length)
+ lineOffset += currentLineOffset
+ posOffset += currentPosOffset
+ env.macroLines.push({
+ matchPos,
+ matchLine,
+ resultLine,
+ lineOffset,
+ posOffset,
+ currentPosOffset,
+ currentLineOffset,
+ matchLength: match.length,
+ resultLength: resultStr.length,
+ })
+ }
+ }
+ })
+
+ state.src = head + hookAfter(result.value, result.vars)
+ state.env.originSource = state.env.source
+ state.env.source = state.src
+
+ return false
+ })
+ })
+
+ ctx.registerHook('STARTUP', () => {
+ ctx.statusBar.tapMenus(menus => {
+ const list = menus['status-bar-tool']?.list
+ if (list) {
+ const id = 'plugin.markdown-macro.copy-markdown'
+ const env = ctx.view.getRenderEnv()
+ const menu: MenuItem = {
+ id,
+ type: 'normal',
+ hidden: !(env?.attributes?.enableMacro) || env.safeMode,
+ title: ctx.i18n.t('status-bar.tool.macro-copy-markdown'),
+ onClick: () => {
+ ctx.utils.copyText(ctx.view.getRenderEnv()?.source)
+ }
+ }
+
+ const item = list.find(x => x.type === 'normal' && x.id === id)
+ if (item) {
+ Object.assign(item, menu)
+ } else {
+ list.push(menu)
+ }
+ }
+ })
+ })
+
+ ctx.registerHook('VIEW_RENDERED', () => {
+ ctx.statusBar.refreshMenu()
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ [= Macro', insertText: '[= ${1:1+1} =]' },
+ { language: 'markdown', label: '/ [= Macro $include', insertText: '[= \\$include(\'$1\') =]' },
+ { language: 'markdown', label: '/ [= Macro $afterMacro', insertText: '[= \\$afterMacro(src => { \n return src.toUpperCase(); \n}) =]' },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/\[=/, { token: 'keyword', next: '@monacoEnd', nextEmbedded: 'text/javascript' }],
+ )
+
+ mdLanguage.tokenizer.monacoEnd = [
+ [/=\]/, { token: 'keyword', next: '@pop', nextEmbedded: '@pop' }]
+ ]
+ })
+
+ ctx.setting.changeSchema(schema => {
+ schema.groups.push({ label: 'T_setting-panel.tabs.macros', value: 'macros' })
+ schema.properties.macros = {
+ defaultValue: [],
+ type: 'array',
+ title: 'T_setting-panel.schema.repos.repos',
+ format: 'table',
+ group: 'macros',
+ items: {
+ type: 'object',
+ title: 'T_setting-panel.schema.macros.macros',
+ properties: {
+ match: {
+ type: 'string',
+ title: 'T_setting-panel.schema.macros.match',
+ defaultValue: '',
+ maxLength: 50,
+ options: {
+ inputAttributes: { placeholder: 'T_setting-panel.schema.macros.match-placeholder' }
+ },
+ },
+ replace: {
+ type: 'string',
+ title: 'T_setting-panel.schema.macros.replace',
+ defaultValue: '',
+ format: 'textarea',
+ options: {
+ inputAttributes: {
+ placeholder: 'T_setting-panel.schema.macros.replace-placeholder',
+ style: 'height: auto; resize: vertical; min-height: 37px;',
+ rows: 1,
+ }
+ },
+ }
+ } as any
+ },
+ }
+ })
+
+ ctx.registerHook('SETTING_BEFORE_WRITE', ({ settings }) => {
+ if (settings.macros && Array.isArray(settings.macros)) {
+ settings.macros = settings.macros.filter(x => x.match && x.replace)
+ }
+ })
+
+ function buildGlobalMacroReplacement (settings: BuildInSettings) {
+ const macros = settings.macros || []
+ globalMacroReplacement = {}
+ macros.forEach(x => {
+ globalMacroReplacement[x.match] = x.replace
+ })
+ }
+
+ ctx.registerHook('SETTING_FETCHED', ({ settings }) => {
+ buildGlobalMacroReplacement(settings)
+ }, true)
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys, settings }) => {
+ if (changedKeys.includes('macros')) {
+ buildGlobalMacroReplacement(settings)
+ ctx.view.render()
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-mermaid.ts b/src/renderer/plugins/markdown-mermaid.ts
index b7c4a94b8..d5341e976 100644
--- a/src/renderer/plugins/markdown-mermaid.ts
+++ b/src/renderer/plugins/markdown-mermaid.ts
@@ -1,30 +1,37 @@
-import Markdown from 'markdown-it'
-import mermaid from 'mermaid/dist/mermaid.js'
-import { Plugin } from '@fe/context/plugin'
+import type Markdown from 'markdown-it'
import { h } from 'vue'
-
-const mermaidChart: any = (code: string) => {
- try {
- return h('div', { key: code, class: 'mermaid reduce-brightness' }, code)
- } catch ({ str }) {
- return h('pre', str)
- }
-}
+import type { Plugin } from '@fe/context'
+import { getInitialized, getLoadStatus } from '@fe/others/extension'
+import { t } from '@fe/services/i18n'
const MermaidPlugin = (md: Markdown) => {
- mermaid.initialize({})
+ const extensionId = '@yank-note/extension-mermaid'
+
+ const checkExtensionLoaded = () => !!getLoadStatus(extensionId).version
+
+ const render = () => {
+ if (!getInitialized()) {
+ return null
+ }
+
+ return h('p', h(
+ 'a',
+ { href: `javascript:ctx.showExtensionManager('${extensionId}')` },
+ h('i', t('install-extension-tips', 'Mermaid'))
+ ))
+ }
const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ if (checkExtensionLoaded()) {
+ return temp(tokens, idx, options, env, slf)
+ }
+
const token = tokens[idx]
- const code = token.content.trim()
if (token.info === 'mermaid') {
- return mermaidChart(code)
- }
- const firstLine = code.split(/\n/)[0].trim()
- if (firstLine === 'gantt' || firstLine === 'sequenceDiagram' || firstLine.match(/^graph (?:TB|BT|RL|LR|TD);?$/)) {
- return mermaidChart(code)
+ return render() as any
}
+
return temp(tokens, idx, options, env, slf)
}
}
@@ -32,12 +39,14 @@ const MermaidPlugin = (md: Markdown) => {
export default {
name: 'markdown-mermaid',
register: ctx => {
- ctx.theme.addStyles(`
- .markdown-view .markdown-body .mermaid {
- background: #fff;
- }
- `)
ctx.markdown.registerPlugin(MermaidPlugin)
- ctx.registerHook('ON_VIEW_RENDERED', () => mermaid.init('.mermaid'))
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` Mermaid', insertText: '```mermaid\ngraph LR\n${1:A[Hard] --> |Text| B(Round)}\n```\n', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-mind-map.ts b/src/renderer/plugins/markdown-mind-map.ts
index cc6eb52b3..ad301ad96 100644
--- a/src/renderer/plugins/markdown-mind-map.ts
+++ b/src/renderer/plugins/markdown-mind-map.ts
@@ -1,16 +1,206 @@
-import { defineComponent, h, onMounted, ref, watch } from 'vue'
+import { defineComponent, h, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { debounce } from 'lodash-es'
import Renderer from 'markdown-it/lib/renderer'
-import { Plugin } from '@fe/context/plugin'
-import crypto from '@fe/utils/crypto'
-import { dataURItoBlobLink } from '@fe/utils'
-import env from '@fe/utils/env'
-import storage from '@fe/utils/storage'
-import { buildSrc } from '@fe/context/embed'
+import { Plugin } from '@fe/context'
+import { downloadDataURL, getLogger, strToBase64, waitCondition } from '@fe/utils'
+import { openWindow } from '@fe/support/env'
+import * as storage from '@fe/utils/storage'
+import { buildSrc } from '@fe/support/embed'
+import store from '@fe/support/store'
+import { registerHook, removeHook } from '@fe/core/hook'
+import { t } from '@fe/services/i18n'
+import { getRenderIframe } from '@fe/services/view'
+import { DOM_ATTR_NAME, DOM_CLASS_NAME } from '@fe/support/args'
+import type { ExportType } from '@fe/types'
+
+const logger = getLogger('markdown-mind-map')
const layoutStorageKey = 'mind-map-layout'
let links = ''
+let mindMapId = 0
+const instances = new Map()
+let window: any // render iframe content window
+let document: any // render iframe content document
+
+async function processRenderWindow () {
+ window = (await getRenderIframe()).contentWindow!
+ document = window.document
+
+ // kityminder has memory leak at CustomEvent, make CustomEvent readonly
+ const CustomEvent = window.CustomEvent
+ Object.defineProperty(window, 'CustomEvent', {
+ get: () => CustomEvent,
+ set: () => undefined
+ })
+
+ Object.defineProperty(window, 'kity', {
+ get: () => {
+ logger.debug('new kity')
+ return window.kityM()
+ },
+ })
+
+ Object.defineProperty(window, 'kityminder', {
+ get: () => {
+ logger.debug('new kityminder')
+ return window.kityminderM && window.kityminderM()
+ },
+ })
+}
+
+processRenderWindow()
+
+async function newMinder () {
+ await waitCondition(() => !!(window.kityminder?.Minder))
+
+ // hack addEventListener, fix memory leak.
+ const realAddEventListener = window.addEventListener.bind(window)
+ const events: {type: string, listener: any}[] = []
+ window.addEventListener = (type: string, listener: any) => {
+ logger.debug('hack addEventListener', type)
+ events.push({ type, listener })
+ realAddEventListener(type, listener)
+ }
+
+ const kityminder = window.kityminder
+ const km = new kityminder.Minder()
+
+ // restore addEventListener
+ window.addEventListener = realAddEventListener
+
+ // fix bug: origin enableAnimation has bug not work.
+ km.enableAnimation = function () {
+ km.setOption('enableAnimation', true)
+ km.setOption('layoutAnimationDuration', 300)
+ km.setOption('viewAnimationDuration', 100)
+ km.setOption('zoomAnimationDuration', 300)
+ }
+
+ const paperEvent = 'click dblclick mousedown contextmenu mouseup mousemove mouseover mousewheel DOMMouseScroll touchstart touchmove touchend dragenter dragleave drop'
+
+ const firePharse = km._firePharse.bind(km)
+ km._bindEvents = function () {
+ this._paper.on(paperEvent, firePharse)
+ window.addEventListener('resize', firePharse)
+ events.push({ type: 'resize', listener: firePharse })
+ }
+
+ const camera = km._commands.camera.execute
+ km._commands.camera.execute = function (km: any, focusNode: any) {
+ if (km._status === 'normal') {
+ return
+ }
+
+ if (focusNode) {
+ camera.call(this, km, focusNode)
+ return
+ }
+
+ // eslint-disable-next-line no-proto
+ const Point = km.getRoot().getVertexIn().__proto__.constructor
+
+ const tpl = km.getTemplate()
+
+ if (['right', 'fish-bone'].includes(tpl)) {
+ const viewport = km.getPaper().getViewPort()
+ const x = viewport.center.x - viewport.center.x / viewport.zoom + 20 / viewport.zoom
+ const y = viewport.center.y + 10 / viewport.zoom
+ const duration = km.getOption('viewAnimationDuration')
+ km._viewDragger.moveTo(new Point(x, y), duration)
+ } else if (['structure', 'filetree'].includes(tpl)) {
+ const viewport = km.getPaper().getViewPort()
+ const x = viewport.center.x
+ const y = viewport.center.y - viewport.center.y / viewport.zoom + 40 / viewport.zoom
+ const duration = km.getOption('viewAnimationDuration')
+ km._viewDragger.moveTo(new Point(x, y), duration)
+ } else {
+ camera.call(this, km)
+ }
+ }
+
+ // disable mouseup event listening
+ km._modules.Select.init = () => 0
+
+ // fix bug: origin dispose has bug not work.
+ km.viewer.dispose = function () {
+ try {
+ document.removeEventListener('keydown', this.hotkeyHandler)
+ this.close()
+ } catch {}
+ }
+
+ // fix bug: https://github.com/fex-team/kityminder-editor/issues/704
+ km.clearSelect = function () {
+ paperEvent.split(' ').forEach(type => this._paper.off(type, firePharse))
+ km.viewer.dispose()
+ events.forEach(({ type, listener }) => {
+ window.removeEventListener(type, listener)
+ })
+ }
+
+ const kmDestroy = km.destroy.bind(km)
+ km.destroy = function () {
+ km._bindEvents = () => 0
+ kmDestroy()
+ }
+
+ // hack, avoid KM editor auto focus.
+ km.focus = () => 0
+
+ km._setTemplate = km.setTemplate
+
+ const importNode = km.importNode.bind(km)
+ km.importNode = function (node: any, json: any) {
+ if (json && json.data && json.data.text) {
+ json.data.text = (json.data.text as string).replace(/^\[(\d+)\]\s*/, (match, $1) => {
+ const num = parseInt($1)
+ if (num > 0) {
+ json.data.priority = num
+ return ''
+ }
+
+ return match
+ })
+ }
+
+ return importNode(node, json)
+ }
+
+ const priorityRender = km._modules.PriorityModule.renderers.left
+ const priorityIconCreate = priorityRender.prototype.create
+ priorityRender.prototype.create = () => {
+ const icon = priorityIconCreate()
+ const setValue = icon.setValue.bind(icon)
+ icon.setValue = function (val: number) {
+ this.mask.fill('#A3A3A3')
+ this.back.fill('#515151')
+ setValue(val)
+ }
+
+ return icon
+ }
+
+ km.disableAnimationAwhile = async (fn: Function) => {
+ // hack for avoid auto set template
+ km.setTemplate = () => 0
+ km.disableAnimation()
+ await fn()
+ km.enableAnimation()
+ // recover setTemplate
+ km.setTemplate = km._setTemplate
+ }
+
+ const importJson = km.importJson.bind(km)
+ km.importJson = function (json: any) {
+ if (json) {
+ importJson(json)
+ }
+ }
+
+ return km
+}
+
const buildSrcdoc = (json: string, btns: string) => {
return `
${links}
@@ -19,6 +209,16 @@ const buildSrcdoc = (json: string, btns: string) => {
margin: 0;
padding: 0;
height: 100%;
+ background: #fff;
+ }
+
+ .mind-map-action {
+ position: absolute;
+ right: 10px;
+ top: 3px;
+ z-index: 1;
+ text-align: right;
+ background: transparent;
}
#minder-view {
@@ -65,32 +265,21 @@ const buildSrcdoc = (json: string, btns: string) => {
`
}
-const render = async (ele: HTMLElement, content: string) => {
- const code = (content || '').trim()
-
+const init = async (ele: HTMLElement) => {
const div = document.createElement('div')
div.setAttribute('minder-data-type', 'text')
div.style.position = 'relative'
- div.style.height = '400px'
+ div.style.height = '300px'
+ div.style.minHeight = '300px'
ele.innerHTML = ''
ele.appendChild(div)
- const km = new (window as any).kityminder.Minder()
- // Hack 一下，防止脑图自动聚焦
- km.focus = () => 0
+ const km = await newMinder()
+
km.setup(div)
km.disable()
- try {
- await km.importData('text', code)
- km.useTemplate(storage.get(layoutStorageKey, 'default'))
- } catch (error) {
- await km.importData('text', '转换错误\n 1. 请保证大纲只有一个根项目\n 2. 请保证大纲层级正确')
- km.useTemplate('structure')
- }
-
- km.execCommand('hand')
- km.useTheme('fresh-green-compat')
- km.execCommand('camera')
+ km.setOption('defaultTheme', 'fresh-green-compat')
+ km.setTemplate(storage.get(layoutStorageKey, 'default'))
const switchLayout = () => {
const tplList = ['default', 'right', 'structure', 'filetree', 'tianpan', 'fish-bone']
@@ -117,25 +306,32 @@ const render = async (ele: HTMLElement, content: string) => {
const zoomOut = () => km.execCommand('zoomOut')
const zoomIn = () => km.execCommand('zoomIn')
+ const fitHeight = () => {
+ const paper = km.getPaper()
+ const kmView = paper.container
+ const svgG = paper.shapeNode
+ if (kmView && svgG) {
+ kmView.style.height = (svgG.getBoundingClientRect().height + 40) + 'px'
+ km._modules.View.events.resize.apply(km)
+ km.zoom(km.getZoomValue()) // reset view port
+ setTimeout(() => {
+ km.execCommand('camera')
+ }, 0)
+ }
+ }
const exportData = async (type: 'png' | 'svg' | 'km') => {
- const download = (url: string, name: string) => {
- const link = document.createElement('a')
- link.href = dataURItoBlobLink(url)
- link.target = '_blank'
- link.download = name
- link.click()
- }
+ const filename = `mindmap-${Date.now()}.${type}`
switch (type) {
case 'svg':
- download('data:image/svg+xml;base64,' + crypto.strToBase64(await km.exportData('svg')), 'mindmap.svg')
+ downloadDataURL(filename, 'data:image/svg+xml;base64,' + strToBase64(await km.exportData('svg')))
break
case 'km':
- download('data:application/octet-stream;base64,' + crypto.strToBase64(await km.exportData('json')), 'mindmap.km')
+ downloadDataURL(filename, 'data:application/octet-stream;base64,' + strToBase64(await km.exportData('json')))
break
case 'png':
- download(await km.exportData('png'), 'mindmap.png')
+ downloadDataURL(filename, await km.exportData('png'))
break
default:
break
@@ -144,7 +340,7 @@ const render = async (ele: HTMLElement, content: string) => {
const buildButton = (text: string, fun: () => void, onclick = '') => {
const button = document.createElement('button')
- button.style.cssText = 'margin-left: 5px;font-size: 14px;background: #cacaca; border: 0; padding: 0 6px; color: #2c2b2b; cursor: pointer; border-radius: 2px; transition: all .1s ease-in-out; line-height: 24px;'
+ button.className = 'small'
button.innerText = text
button.onclick = fun
button.dataset.onclick = `${onclick}()`
@@ -152,59 +348,161 @@ const render = async (ele: HTMLElement, content: string) => {
}
const action = document.createElement('div')
- action.className = 'no-print'
- action.style.cssText = 'position: absolute; right: 15px; top: 3px; z-index: 1;'
- action.appendChild(buildButton('放大', zoomIn, 'zoomIn'))
- action.appendChild(buildButton('缩小', zoomOut, 'zoomOut'))
- action.appendChild(buildButton('切换布局', switchLayout, 'switchLayout'))
- action.appendChild(buildButton('紧凑/宽松', switchCompat, 'switchCompat'))
+ action.className = 'mind-map-action skip-print'
+ action.appendChild(buildButton(t('mind-map.zoom-in'), zoomIn, 'zoomIn'))
+ action.appendChild(buildButton(t('mind-map.zoom-out'), zoomOut, 'zoomOut'))
+ action.appendChild(buildButton(t('mind-map.switch-layout'), switchLayout, 'switchLayout'))
+ action.appendChild(buildButton(t('mind-map.switch-loose'), switchCompat, 'switchCompat'))
const actionsStr = action.outerHTML.replace(/data-onclick/g, 'onclick')
- action.appendChild(buildButton('新窗口打开', () => {
+ action.appendChild(buildButton(t('open-in-new-window'), () => {
const srcdoc = buildSrcdoc(JSON.stringify(km.exportJson()), actionsStr)
- env.openWindow(buildSrc(srcdoc, '查看图形'), '_blank', { backgroundColor: '#fff' })
+ openWindow(buildSrc(srcdoc, t('view-figure'), true), '_blank', { backgroundColor: '#fff' })
}))
- action.appendChild(buildButton('导出 PNG', () => exportData('png')))
- action.appendChild(buildButton('导出 SVG', () => exportData('svg')))
- action.appendChild(buildButton('导出 KM', () => exportData('km')))
+ action.prepend(buildButton(t('mind-map.fit-height'), fitHeight, 'fitHeight'))
+ action.appendChild(buildButton('PNG', () => exportData('png')))
+ action.appendChild(buildButton('SVG', () => exportData('svg')))
+ action.appendChild(buildButton('KM', () => exportData('km')))
div.appendChild(action)
+
+ return km
+}
+
+const render = async (km: any, content: string) => {
+ if (!km) return
+
+ let code = (content || '').trim()
+
+ try {
+ // replace 2 spaces to 4 spaces
+ if (code.match(/^ {2}[^ ]/gm)) {
+ code = code.replace(/^ {2,}[^ ]/gm, (match) => {
+ return match.replace(/ {2}/g, ' ')
+ })
+ }
+
+ await km.importData('text', code)
+ } catch (error) {
+ await km.importData('text', t('mind-map.convert-error'))
+ km?.execCommand('camera')
+ }
}
const MindMap = defineComponent({
name: 'mind-map',
props: {
+ attrs: Object,
content: {
type: String,
default: ''
}
},
setup (props) {
+ const id = `mind-map-${mindMapId++}`
const container = ref()
+ const img = ref('')
- const renderMindMap = debounce(() => {
- container.value && render(container.value, props.content)
- }, 1000, { leading: true })
+ let km: any = null
+ const renderMindMap = debounce(async () => {
+ if (!container.value) {
+ return
+ }
+
+ if (!km) {
+ km = await init(container.value)
+ km.disableAnimationAwhile(async () => {
+ await render(km, props.content)
+ km?.execCommand('hand')
+ km?.execCommand('camera')
+ })
+ instances.set(id, km)
+ } else {
+ km.disableAnimationAwhile(() => render(km, props.content))
+ }
+ }, 200, { leading: true })
+
+ function clean () {
+ km && km.destroy()
+ km = null
+ instances.delete(id)
+ }
+
+ function reload () {
+ clean()
+ renderMindMap()
+ }
+
+ async function beforePrint ({ type }: { type: ExportType }) {
+ if (type === 'print' || type === 'pdf') {
+ const svg = await km.exportData('svg')
+ img.value = 'data:image/svg+xml;base64,' + strToBase64(svg)
+ }
+ }
+
+ function afterPrint () {
+ img.value = ''
+ }
watch(() => props.content, renderMindMap)
- onMounted(renderMindMap)
+ watch(() => store.state.showView, (visible) => {
+ if (visible) {
+ nextTick(reload)
+ }
+ })
+
+ onMounted(() => setTimeout(renderMindMap, 0))
+
+ registerHook('I18N_CHANGE_LANGUAGE', reload)
+ registerHook('EXPORT_BEFORE_PREPARE', beforePrint)
+ registerHook('EXPORT_AFTER_PREPARE', afterPrint)
+ onBeforeUnmount(() => {
+ clean()
+ removeHook('I18N_CHANGE_LANGUAGE', reload)
+ removeHook('EXPORT_BEFORE_PREPARE', beforePrint)
+ removeHook('EXPORT_AFTER_PREPARE', afterPrint)
+ })
- return () => h('div', { ref: container, class: 'mind-map reduce-brightness' })
+ let focused = false
+
+ const className = [
+ 'mind-map',
+ DOM_CLASS_NAME.REDUCE_BRIGHTNESS,
+ DOM_CLASS_NAME.SKIP_EXPORT,
+ DOM_CLASS_NAME.SKIP_PRINT,
+ ].join(' ')
+
+ return () => [
+ img.value ? h('p', { ...props.attrs }, h('img', {
+ src: img.value,
+ [DOM_ATTR_NAME.ONLY_CHILD]: true,
+ })) : null,
+ h('div', {
+ id,
+ ref: container,
+ class: className,
+ [DOM_ATTR_NAME.DISPLAY_NONE]: img.value ? true : undefined,
+ tabIndex: -1,
+ onClickCapture: () => { container.value?.focus() },
+ onFocus: () => { focused = true },
+ onBlur: () => { focused = false },
+ onMousewheelCapture: (e: WheelEvent) => { !focused && e.stopPropagation() },
+ ...props.attrs,
+ })
+ ]
}
})
-const renderRule: Renderer.RenderRule = (tokens, idx, options, { source }, slf) => {
+const renderRule: Renderer.RenderRule = (tokens, idx, options, { bMarks, source }, slf) => {
const token = tokens[idx]
const nextToken = tokens[idx + 1]
- if (token.level === 0 && token.map && nextToken && nextToken.attrGet('class')?.includes('mindmap')) {
+ if (token.map && nextToken && nextToken.attrGet('class')?.includes('mindmap')) {
const content = source
- .split('\n')
- .slice(token.map[0], token.map[1])
- .join('\n')
+ .substring(bMarks[token.map[0]], bMarks[token.map[1]])
.replace(/\{.mindmap[^}]*\}/gm, '')
.replace(/^(\s*)([+-]*|\d+.) /gm, '$1')
- return h(MindMap, { content }) as any
+ return h(MindMap, { attrs: token.meta?.attrs, content }) as any
}
return slf.renderToken(tokens, idx, options)
@@ -213,25 +511,76 @@ const renderRule: Renderer.RenderRule = (tokens, idx, options, { source }, slf)
export default {
name: 'markdown-mind-map',
register: ctx => {
- ctx.markdown.registerPlugin(md => {
- md.renderer.rules.bullet_list_open = renderRule
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body .mind-map {
+ overflow: hidden;
+ }
+
+ .markdown-view .markdown-body .mind-map > div {
+ margin-top: -20px;
+ }
- const style = document.createElement('link')
- style.rel = 'stylesheet'
- style.href = '/kity/kityminder.core.css'
- document.getElementsByTagName('head')[0].appendChild(style)
+ .markdown-view .markdown-body .mind-map .mind-map-action {
+ position: absolute;
+ right: 10px;
+ top: 23px;
+ z-index: 1;
+ text-align: right;
+ background: transparent;
+ opacity: 0;
+ transition: opacity .2s;
+ }
+
+ .markdown-view .markdown-body .mind-map:hover .mind-map-action {
+ opacity: 1;
+ }
+ `)
+
+ async function injectScripts () {
+ const style = await ctx.view.addStyleLink('/kity/kityminder.core.css')
+ const script1 = await ctx.view.addScript('/kity/kity.min.js')
+ script1.onload = async () => {
+ const script2 = await ctx.view.addScript('/kity/kityminder.core.min.js')
+ links = [style.outerHTML, script1.outerHTML, script2.outerHTML].join('\n')
+ }
+ }
- const script1 = document.createElement('script')
- script1.src = '/kity/kity.min.js'
- script1.async = false
- document.body.appendChild(script1)
+ injectScripts()
+
+ ctx.markdown.registerPlugin(async md => {
+ md.renderer.rules.bullet_list_open = renderRule
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', async ({ node, options }) => {
+ if (node.classList.contains('mind-map') && node.id) {
+ const km = instances.get(node.id)
+ if (km) {
+ const img = document.createElement('img')
+ img.alt = 'mind-map'
+ img.setAttribute(DOM_ATTR_NAME.ONLY_CHILD, 'true')
+
+ if (options.preferPng) {
+ img.src = await km.exportData('png')
+ } else {
+ const svg = await km.exportData('svg')
+ img.src = 'data:image/svg+xml;base64,' + ctx.utils.strToBase64(svg)
+ }
+
+ const p = document.createElement('p')
+ Object.assign(p.dataset, node.dataset)
+ p.appendChild(img)
+
+ node.outerHTML = p.outerHTML
+ }
+ }
+ })
- const script2 = document.createElement('script')
- script2.src = '/kity/kityminder.core.min.js'
- script2.async = false
- document.body.appendChild(script2)
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
- links = [style.outerHTML, script1.outerHTML, script2.outerHTML].join('\n')
+ items.push(
+ { language: 'markdown', label: '/ + MindMap', insertText: '+ ${1:Subject}{.mindmap}\n + ${2:Topic}', block: true },
+ )
})
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-plantuml.ts b/src/renderer/plugins/markdown-plantuml.ts
index 532425265..9aa08a4bd 100644
--- a/src/renderer/plugins/markdown-plantuml.ts
+++ b/src/renderer/plugins/markdown-plantuml.ts
@@ -1,15 +1,28 @@
// https://github.com/DeepElement/markdown-it-plantuml-offline
import { debounce } from 'lodash-es'
+import pako from 'pako'
import { defineComponent, h, nextTick, onMounted, reactive, ref, watch } from 'vue'
import Markdown from 'markdown-it'
import Token from 'markdown-it/lib/token'
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
+import { DOM_ATTR_NAME } from '@fe/support/args'
const emptySrc = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
+const backgroundImage = 'url(data:image/gif;base64,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)'
+
+const baseUrl = location.origin + '/api/plantuml'
const MarkdownItPlugin = function umlPlugin (md: Markdown, options: any) {
function generateSourceDefault (umlCode: string) {
- return location.origin + '/api/plantuml/png?data=' + encodeURIComponent(umlCode)
+ if (!umlCode.trim()) {
+ return 'data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 32 32"><defs><linearGradient id="a" x1="-33.423" y1="-250.911" x2="-33.353" y2="-250.858" gradientTransform="matrix(37.134, 26.001, 13.575, -19.387, 4673.473, -3982.019)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#767676"/><stop offset="1"/></linearGradient><linearGradient id="b" x1="-32.107" y1="-242.563" x2="-32.028" y2="-242.586" gradientTransform="matrix(81.081, 56.774, 17.306, -24.715, 6804.021, -4149.644)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#0079b9"/><stop offset="1"/></linearGradient><linearGradient id="c" x1="-33.282" y1="-243.423" x2="-33.224" y2="-243.455" gradientTransform="matrix(60.003, 42.015, 34.184, -48.82, 10343.005, -10469.084)" xlink:href="#b"/><linearGradient id="d" x1="12.356" y1="26.268" x2="14.011" y2="26.268" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#595959"/><stop offset="0.087" stop-color="#6e6e6e"/><stop offset="0.242" stop-color="#8c8c8c"/><stop offset="0.405" stop-color="#a4a4a4"/><stop offset="0.577" stop-color="#b5b5b5"/><stop offset="0.765" stop-color="#bfbfbf"/><stop offset="1" stop-color="#c2c2c2"/></linearGradient><linearGradient id="e" x1="18.291" y1="26.171" x2="19.946" y2="26.171" xlink:href="#d"/><linearGradient id="f" x1="24.44" y1="26.171" x2="26.096" y2="26.171" xlink:href="#d"/></defs><rect width="100%" height="100%" fill="#fff"/><title>file_type_plantuml</title><polygon points="20.305 17.872 27.16 22.418 21.72 25.493 14.861 20.999 20.305 17.872" style="fill:#1c0a42"/><path d="M21.716,25.619l-.055-.036-7.005-4.59,5.653-3.247,7.056,4.68Zm-6.65-4.613,6.658,4.362,5.231-2.957L20.3,18Z"/><polygon points="26.401 11.909 29.418 13.592 27.07 15.088 24.213 13.247 26.401 11.909" style="fill:url(#a)"/><path d="M27.069,15.215l-3.058-1.97,2.387-1.46,3.228,1.8Zm-2.654-1.966L27.07,14.96,29.208,13.6l-2.8-1.565Z"/><polygon points="14.498 17.807 21.354 22.354 15.914 25.429 9.055 20.935 14.498 17.807" style="fill:#ffbd3f"/><path d="M15.91,25.554l-.055-.036L8.85,20.929,14.5,17.681l7.056,4.68ZM9.26,20.941,15.918,25.3l5.231-2.957-6.654-4.413Z"/><polygon points="7.99 17.966 14.954 22.366 9.577 25.504 2.218 20.849 7.99 17.966" style="fill:#a11f40"/><path d="M9.575,25.629,2,20.838l6-3,7.164,4.527ZM2.436,20.86,9.58,25.378l5.168-3.016L7.984,18.089Z"/><polygon points="2.111 21.021 9.443 25.515 9.443 29.063 2.111 24.332 2.111 21.021" style="fill:url(#b)"/><path d="M9.55,29.26,2,24.391V20.829L9.55,25.455ZM2.218,24.274l7.118,4.592V25.575L2.218,21.213Z"/><polygon points="24.071 13.343 27.009 15.222 27.009 22.131 24.071 20.247 24.071 13.343" style="fill:url(#c)"/><path d="M27.063,22.229l-3.045-1.953V13.245l3.045,1.947Zm-2.938-2.012,2.831,1.815V15.251l-2.831-1.81Z"/><polygon points="27.149 22.526 27.149 15.194 29.514 13.775 29.514 29.149 28.331 29.149 9.646 29.149 9.646 25.601 15.086 22.526 15.785 25.601 15.796 25.601 21.472 22.526 21.891 25.601 21.945 25.601 27.149 22.526" style="fill:#fff"/><path d="M29.621,29.256H9.539V25.538l5.62-3.177.7,3.083,5.7-3.087.422,3.1,5.061-2.991V15.133l2.58-1.548ZM9.753,29.041H29.407V13.964l-2.151,1.29v7.332l-.053.031-5.229,3.09H21.8l-.411-3.014-5.564,3.014H15.7l-.686-3.018-5.26,2.973Z"/><rect x="12.356" y="25.44" width="1.656" height="1.656" rx="0.215" ry="0.215" style="fill:url(#d)"/><path d="M13.8,27.2H12.57a.322.322,0,0,1-.322-.322V25.655a.322.322,0,0,1,.322-.322H13.8a.322.322,0,0,1,.322.322v1.226A.322.322,0,0,1,13.8,27.2ZM12.57,25.547a.108.108,0,0,0-.107.107v1.226a.108.108,0,0,0,.107.107H13.8a.108.108,0,0,0,.107-.107V25.655a.108.108,0,0,0-.107-.107Z"/><rect x="18.291" y="25.343" width="1.656" height="1.656" rx="0.215" ry="0.215" style="fill:url(#e)"/><path d="M19.732,27.106H18.505a.322.322,0,0,1-.322-.322V25.558a.322.322,0,0,1,.322-.322h1.226a.322.322,0,0,1,.322.322v1.226A.322.322,0,0,1,19.732,27.106Zm-1.226-1.656a.108.108,0,0,0-.107.107v1.226a.108.108,0,0,0,.107.107h1.226a.108.108,0,0,0,.107-.107V25.558a.108.108,0,0,0-.107-.107Z"/><rect x="24.44" y="25.343" width="1.656" height="1.656" rx="0.215" ry="0.215" style="fill:url(#f)"/><path d="M25.881,27.106H24.655a.322.322,0,0,1-.322-.322V25.558a.322.322,0,0,1,.322-.322h1.226a.322.322,0,0,1,.322.322v1.226A.322.322,0,0,1,25.881,27.106Zm-1.226-1.656a.108.108,0,0,0-.107.107v1.226a.108.108,0,0,0,.107.107h1.226a.108.108,0,0,0,.107-.107V25.558a.108.108,0,0,0-.107-.107Z"/><path d="M27.215,11.23c-.052.069-.417-.262-.653-.526a4.408,4.408,0,0,1-.516-.73A2.6,2.6,0,0,1,25.7,9.2a2.358,2.358,0,0,1-.052-.682,2.959,2.959,0,0,1,.129-.749,3.142,3.142,0,0,1,.787-1.207,15.532,15.532,0,0,0,1.283-1.4,3.062,3.062,0,0,0,.479-.927,3.979,3.979,0,0,0,.151-.855c.019-.364-.025-.593.023-.613s.215.274.287.564a3.167,3.167,0,0,1-.458,2.1,6.9,6.9,0,0,1-1.094,1.448,2.8,2.8,0,0,0-.849,1.234A2.466,2.466,0,0,0,26.3,8.8a3.465,3.465,0,0,0,.476,1.542C27.064,10.914,27.256,11.175,27.215,11.23Z" style="fill:#ea2d2e"/><path d="M27.193,11.266c-.124,0-.492-.365-.651-.544a4.478,4.478,0,0,1-.52-.734,2.628,2.628,0,0,1-.346-.781,2.375,2.375,0,0,1-.053-.69,2.978,2.978,0,0,1,.13-.756,3.208,3.208,0,0,1,.793-1.216c.294-.331.5-.528.659-.686a4.393,4.393,0,0,0,.622-.711,3.052,3.052,0,0,0,.476-.919,3.951,3.951,0,0,0,.15-.849c.008-.159,0-.294,0-.393,0-.159-.006-.225.038-.243a.05.05,0,0,1,.043,0,1.226,1.226,0,0,1,.28.579,3.167,3.167,0,0,1-.46,2.121,6.928,6.928,0,0,1-1.1,1.453c-.055.06-.109.116-.162.171a2.3,2.3,0,0,0-.681,1.052,2.47,2.47,0,0,0-.082.673,3.458,3.458,0,0,0,.473,1.53c.114.231.215.415.289.549.129.235.178.323.142.369h0a.051.051,0,0,1-.04.02ZM28.512,2.8a.863.863,0,0,0,0,.19c0,.1.007.236,0,.4a4.021,4.021,0,0,1-.152.861,3.106,3.106,0,0,1-.483.934,4.437,4.437,0,0,1-.629.719c-.162.158-.364.354-.657.683a3.168,3.168,0,0,0-.782,1.2,2.933,2.933,0,0,0-.128.743,2.325,2.325,0,0,0,.052.675,2.59,2.59,0,0,0,.341.767,4.422,4.422,0,0,0,.513.725,2.035,2.035,0,0,0,.611.526,1.183,1.183,0,0,0-.147-.31c-.074-.134-.175-.318-.29-.551A3.5,3.5,0,0,1,26.278,8.8a2.53,2.53,0,0,1,.084-.688,2.375,2.375,0,0,1,.694-1.075c.052-.055.106-.111.161-.171a6.879,6.879,0,0,0,1.09-1.442,3.119,3.119,0,0,0,.456-2.083A1.281,1.281,0,0,0,28.512,2.8Z"/><path d="M29.972,6.087c-.019-.088-.432-.04-.766.073a2.6,2.6,0,0,0-1.059.722,2.8,2.8,0,0,0-.916,1.855,2.972,2.972,0,0,0,.258,1.06c.221.572.455.773.444,1.225-.007.3-.114.484-.048.549s.314-.1.462-.313a1.8,1.8,0,0,0,.259-1.022c-.046-.815-.6-1.015-.608-1.8a1.858,1.858,0,0,1,.129-.676C28.57,6.509,30.008,6.252,29.972,6.087Z" style="fill:#ea2d2e"/><path d="M27.934,11.617a.094.094,0,0,1-.069-.026c-.046-.046-.03-.122-.005-.237a1.718,1.718,0,0,0,.045-.331,1.374,1.374,0,0,0-.214-.72,5,5,0,0,1-.228-.495,2.98,2.98,0,0,1-.259-1.07,2.81,2.81,0,0,1,.923-1.874,2.64,2.64,0,0,1,1.07-.729,1.482,1.482,0,0,1,.766-.1A.065.065,0,0,1,30,6.081h0c.015.07-.092.121-.306.224a2.73,2.73,0,0,0-1.542,1.463,1.827,1.827,0,0,0-.127.667,1.645,1.645,0,0,0,.291.885,1.889,1.889,0,0,1,.317.914,1.814,1.814,0,0,1-.264,1.039.809.809,0,0,1-.421.342Zm1.889-5.549a2.117,2.117,0,0,0-.608.117,2.588,2.588,0,0,0-1.048.715,2.764,2.764,0,0,0-.909,1.837,2.935,2.935,0,0,0,.256,1.05,4.955,4.955,0,0,0,.225.49,1.433,1.433,0,0,1,.22.745,1.765,1.765,0,0,1-.047.341c-.019.091-.035.163-.009.188a.046.046,0,0,0,.038.01.769.769,0,0,0,.382-.32,1.793,1.793,0,0,0,.254-1.005,1.844,1.844,0,0,0-.31-.89,1.711,1.711,0,0,1-.3-.911,1.877,1.877,0,0,1,.13-.686A2.776,2.776,0,0,1,29.67,6.257c.126-.061.283-.136.277-.164l-.008-.007A.264.264,0,0,0,29.823,6.068Z"/></svg>
'
+ }
+
+ const data = btoa(
+ pako.deflateRaw(umlCode).reduce((d, b) => d + String.fromCharCode(b), '')
+ )
+
+ return baseUrl + '?data=' + encodeURIComponent(data)
}
options = options || {}
@@ -102,7 +115,7 @@ const MarkdownItPlugin = function umlPlugin (md: Markdown, options: any) {
const contents = state.src
.split('\n')
- .slice(startLine + 1, nextLine)
+ .slice(startLine, nextLine + 1)
.join('\n')
// We generate a token list for the alt property, to mimic what the image parser does.
@@ -139,17 +152,30 @@ const MarkdownItPlugin = function umlPlugin (md: Markdown, options: any) {
alt: ['paragraph', 'reference', 'blockquote', 'list']
})
md.renderer.rules.uml_diagram = render
+
+ const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
+ md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+ const token = tokens[idx]
+ if (token.info !== 'plantuml') {
+ return temp(tokens, idx, options, env, slf)
+ }
+
+ const src = generateSourceDefault(token.content)
+ return h(Plantuml, { attrs: token.meta?.attrs, src, idx }) as any
+ }
}
const Plantuml = defineComponent({
name: 'plantuml-image',
props: {
- src: String
+ attrs: Object,
+ src: String,
+ idx: Number,
},
setup (props) {
const style = reactive({
backgroundColor: 'transparent',
- backgroundImage: 'url(data:image/gif;base64,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)',
+ backgroundImage,
backgroundPosition: 'center',
backgroundRepeat: 'no-repeat',
width: '32px',
@@ -162,15 +188,19 @@ const Plantuml = defineComponent({
const onLoad = () => {
style.width = 'auto'
style.height = 'auto'
+ style.backgroundImage = 'none'
}
const load = debounce((val: string) => {
- src.value = val
+ src.value = emptySrc
+ setTimeout(() => {
+ style.backgroundImage = backgroundImage
+ src.value = val
+ }, 0)
}, 1000)
watch(() => props.src, val => {
- src.value = emptySrc
- nextTick(() => load(val || ''))
+ load(val || '')
})
onMounted(() => {
@@ -186,26 +216,105 @@ const Plantuml = defineComponent({
style.height = img.value.clientHeight + 'px'
}
- return h('img', {
- ref: img,
- alt: 'plantuml',
- class: 'plantuml-img',
- style,
- src: src.value,
- onLoad
- })
+ return h('p', {
+ ...props.attrs,
+ src: undefined,
+ alt: undefined,
+ [DOM_ATTR_NAME.TOKEN_IDX]: props.idx,
+ }, [
+ h('img', {
+ ref: img,
+ alt: 'plantuml',
+ class: 'plantuml-img',
+ [DOM_ATTR_NAME.ONLY_CHILD]: true,
+ style,
+ src: src.value,
+ onload: onLoad
+ })
+ ])
}
}
})
function render (tokens: Token[], idx: number) {
const token = tokens[idx]
- return h(Plantuml, { src: token.attrGet('src') || emptySrc })
+ return h(Plantuml, {
+ attrs: token.meta?.attrs,
+ src: token.attrGet('src') || emptySrc,
+ idx,
+ })
}
export default {
name: 'markdown-plantuml',
register: ctx => {
- ctx.markdown.registerPlugin(MarkdownItPlugin, { render })
+ const markers = [{
+ openMarker: '@startuml',
+ closeMarker: '@enduml',
+ }, {
+ openMarker: '@startsalt',
+ closeMarker: '@endsalt',
+ }, {
+ openMarker: '@startmindmap',
+ closeMarker: '@endmindmap',
+ }, {
+ openMarker: '@startgantt',
+ closeMarker: '@endgantt',
+ }, {
+ openMarker: '@startwbs',
+ closeMarker: '@endwbs',
+ }, {
+ openMarker: '@startjson',
+ closeMarker: '@endjson',
+ }, {
+ openMarker: '@startyaml',
+ closeMarker: '@endyaml',
+ }]
+ markers.forEach((marker) => {
+ ctx.markdown.registerPlugin(MarkdownItPlugin, { render, ...marker })
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', async ({ node, options }) => {
+ const srcAttr = node.getAttribute('src')
+ if (srcAttr?.startsWith(baseUrl)) {
+ node.removeAttribute('style')
+
+ if (options.preferPng || options.inlineLocalImage) {
+ try {
+ const res: Response = await ctx.api.fetchHttp(srcAttr)
+ const base64Url = await ctx.utils.fileToBase64URL(await res.blob())
+ node.setAttribute('src', base64Url)
+ } catch (error) {
+ console.log(error)
+ }
+ }
+ }
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ ``` PlantUML', insertText: '```plantuml\n@startuml\n${1:a -> b}\n@enduml\n```\n', block: true },
+ { language: 'markdown', label: '/ @startuml PlantUML', insertText: '@startuml\n${1:a -> b}\n@enduml\n', block: true },
+ { language: 'markdown', label: '/ @startsalt PlantUML Salt', insertText: '@startsalt\n{\n Just plain text\n [This is my button]\n () Unchecked radio\n (X) Checked radio\n [] Unchecked box\n [X] Checked box\n "Enter text here "\n ^This is a droplist^\n}\n@endsalt\n', block: true },
+ { language: 'markdown', label: '/ @startmindmap PlantUML Mindmap', insertText: '@startmindmap\n* Debian\n** Ubuntu\n*** Linux Mint\n*** Kubuntu\n*** Lubuntu\n*** KDE Neon\n** LMDE\n** SolydXK\n** SteamOS\n** Raspbian with a very long name\n*** Raspmbc => OSMC\n*** Raspyfi => Volumio\n@endmindmap\n', block: true },
+ { language: 'markdown', label: '/ @startgantt PlantUML Gantt', insertText: '@startgantt\nProject starts 2020-07-01\n[Test prototype] lasts 10 days\n[Prototype completed] happens 2020-07-10\n[Setup assembly line] lasts 12 days\n[Setup assembly line] starts at [Test prototype]\'s end\n@endgantt\n', block: true },
+ { language: 'markdown', label: '/ @startwbs PlantUML Wbs', insertText: '@startwbs\n* Business Process Modelling WBS\n** Launch the project\n*** Complete Stakeholder Research\n*** Initial Implementation Plan\n** Design phase\n*** Model of AsIs Processes Completed\n****< Model of AsIs Processes Completed1\n****> Model of AsIs Processes Completed2\n***< Measure AsIs performance metrics\n***< Identify Quick Wins\n@endwbs\n', block: true },
+ { language: 'markdown', label: '/ @startjson PlantUML Json', insertText: '@startjson\n{\n "fruit":"Apple",\n "size":"Large",\n "color": ["Red", "Green"]\n}\n@endjson\n', block: true },
+ { language: 'markdown', label: '/ @startyaml PlantUML Yaml', insertText: '@startyaml\nfruit: Apple\nsize: Large\ncolor: \n - Red\n - Green\n@endyaml\n', block: true },
+ )
+ })
+
+ ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => {
+ mdLanguage.tokenizer.root.unshift(
+ [/^@@start(uml|salt|mindmap|gantt|wbs|json|yaml)$/, { token: 'string', next: '@plantuml' }],
+ )
+
+ mdLanguage.tokenizer.plantuml = [
+ [/^@@end(uml|salt|mindmap|gantt|wbs|json|yaml)$/, { token: 'string', next: '@pop' }],
+ [/.*$/, 'variable.source']
+ ]
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-render-vnode.ts b/src/renderer/plugins/markdown-render-vnode.ts
index 55917608d..30d20191e 100644
--- a/src/renderer/plugins/markdown-render-vnode.ts
+++ b/src/renderer/plugins/markdown-render-vnode.ts
@@ -1,12 +1,85 @@
-import { createVNode, Fragment, Text, VNode } from 'vue'
-import Token from 'markdown-it/lib/token'
-import Renderer from 'markdown-it/lib/renderer'
+import { createVNode, Fragment, Comment, Text, VNode } from 'vue'
+import type Token from 'markdown-it/lib/token'
+import type Renderer from 'markdown-it/lib/renderer'
import { escapeHtml, unescapeAll } from 'markdown-it/lib/common/utils'
-import { Plugin } from '@fe/context/plugin'
+import { DOM_ATTR_NAME } from '@fe/support/args'
+import type { Plugin } from '@fe/context'
-const attrNameReg = /^[a-zA-Z_:][a-zA-Z0-9:._-]*/
+const sensitiveUrlReg = /^javascript:|vbscript:|file:/i
+const sensitiveAttrReg = /^href|src|xlink:href|poster|srcset$/i
+const attrNameReg = /^[a-zA-Z_:][a-zA-Z0-9:._-]*$/
+const attrEventReg = /^on/i
const defaultRules = {} as any
+function onLeavepictureinpicture (e: Event) {
+ const target = e.target as HTMLMediaElement
+ if (!target.isConnected) {
+ target.pause()
+ } else {
+ (target as any).scrollIntoViewIfNeeded()
+ }
+}
+
+function validateAttrName (name: string) {
+ return attrNameReg.test(name) && !attrEventReg.test(name)
+}
+
+function getLine (token: Token, env?: Record) {
+ const [lineStart, lineEnd] = token.map || [0, 1]
+
+ // macro, calc line offset, see `markdown-macro` plugin.
+ let sOffset = 0
+ if (env?.macroLines && env.bMarks && env.eMarks) {
+ const sPos = env.bMarks[lineStart]
+ for (let i = 0; i < env.macroLines.length; i++) {
+ const { matchPos, lineOffset, posOffset, currentPosOffset } = env.macroLines[i]
+ if (sPos + posOffset > matchPos && sPos + posOffset - currentPosOffset > matchPos) {
+ sOffset = lineOffset
+ } else {
+ break
+ }
+ }
+ }
+
+ return [lineStart + sOffset, lineEnd + sOffset]
+}
+
+function processToken (token: Token, env?: Record) {
+ if (!token.meta) {
+ token.meta = {}
+ }
+
+ if (env?.safeMode) {
+ token.attrs?.forEach(([name, val]) => {
+ name = name.toLowerCase()
+ if (sensitiveAttrReg.test(name) && sensitiveUrlReg.test(val)) {
+ token.attrSet(name, '')
+ }
+
+ if (name === 'href' && val.toLowerCase().startsWith('data:')) {
+ token.attrSet(name, '')
+ }
+ })
+ }
+
+ if (token.block) {
+ const [lineStart, lineEnd] = getLine(token, env)
+
+ if (token.map) {
+ token.attrSet(DOM_ATTR_NAME.SOURCE_LINE_START, String(lineStart + 1))
+ token.attrSet(DOM_ATTR_NAME.SOURCE_LINE_END, String(lineEnd + 1))
+ if (!token.meta.attrs) {
+ token.meta.attrs = {}
+ }
+
+ // transform array to object
+ token.attrs?.forEach(([name, val]) => {
+ token.meta.attrs[name] = val
+ })
+ }
+ }
+}
+
defaultRules.code_inline = function (tokens: Token[], idx: number, _: any, __: any, slf: Renderer) {
const token = tokens[idx]
return createVNode('code', slf.renderAttrs(token) as any, token.content)
@@ -14,10 +87,19 @@ defaultRules.code_inline = function (tokens: Token[], idx: number, _: any, __: a
defaultRules.code_block = function (tokens: Token[], idx: number, _: any, __: any, slf: Renderer) {
const token = tokens[idx]
+ const attrs: any = slf.renderAttrs(token)
+ const preAttrs = {
+ [DOM_ATTR_NAME.SOURCE_LINE_START]: attrs[DOM_ATTR_NAME.SOURCE_LINE_START],
+ [DOM_ATTR_NAME.SOURCE_LINE_END]: attrs[DOM_ATTR_NAME.SOURCE_LINE_END],
+ }
+
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_START]
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_END]
+
return createVNode(
'pre',
- slf.renderAttrs(token) as any,
- [createVNode('code', {}, token.content)]
+ preAttrs,
+ [createVNode('code', attrs, [createVNode(Text, {}, token.content)])]
)
}
@@ -44,11 +126,23 @@ defaultRules.fence = function (tokens: Token[], idx: number, options: any, _: an
return highlighted + '\n'
}
- const buildVNode = (arrts: any) => createVNode(
- 'pre',
- {},
- [createVNode('code', { ...arrts, innerHTML: highlighted }, [])]
- )
+ const buildVNode = (attrs: any) => {
+ const preAttrs = {
+ 'data-info': info,
+ 'data-lang': langName,
+ [DOM_ATTR_NAME.SOURCE_LINE_START]: attrs[DOM_ATTR_NAME.SOURCE_LINE_START],
+ [DOM_ATTR_NAME.SOURCE_LINE_END]: attrs[DOM_ATTR_NAME.SOURCE_LINE_END],
+ }
+
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_START]
+ delete attrs[DOM_ATTR_NAME.SOURCE_LINE_END]
+
+ return createVNode(
+ 'pre',
+ preAttrs,
+ [createVNode('code', { key: highlighted, ...attrs, innerHTML: highlighted }, [])]
+ )
+ }
// If language exists, inject class gently, without modifying original token.
// May be, one day we will add .deepClone() for token and simplify this part, but
@@ -84,6 +178,16 @@ defaultRules.image = function (tokens: Token[], idx: number, options: any, env:
}, [])
}
+defaultRules.media = function (tokens: Token[], idx: number, _options: any, _env: any, slf: Renderer) {
+ const token = tokens[idx]
+ return createVNode(token.tag, {
+ controlsList: 'nodownload',
+ controls: true,
+ onLeavepictureinpicture,
+ ...slf.renderAttrs(token) as any,
+ }, [])
+}
+
defaultRules.hardbreak = function () {
return createVNode('br')
}
@@ -96,19 +200,30 @@ defaultRules.text = function (tokens: Token[], idx: number) {
}
defaultRules.html_block = function (tokens: Token[], idx: number) {
- return createHtmlVNode(tokens[idx].content)
+ const token = tokens[idx] as any
+ if (token.contentVNode) {
+ return token.contentVNode
+ }
+
+ return createHtmlVNode(token.content)
}
defaultRules.html_inline = function (tokens: Token[], idx: number) {
- return createHtmlVNode(tokens[idx].content)
+ const token = tokens[idx] as any
+ if (token.contentVNode) {
+ return token.contentVNode
+ }
+
+ return createHtmlVNode(token.content)
}
function createHtmlVNode (html: string) {
- const div = document.createElement('div')
+ const div = document.createElement('template')
div.innerHTML = html
+ const elements = div.content.children
const children = []
- for (let i = 0; i < div.children.length; i++) {
- const element = div.children[i]
+ for (let i = 0; i < elements.length; i++) {
+ const element = elements[i]
const tagName = element.tagName.toLowerCase()
const attrs: Record = {
key: element.outerHTML
@@ -120,8 +235,9 @@ function createHtmlVNode (html: string) {
}
attrs.innerHTML = element.innerHTML
+ attrs.key = element.innerHTML
- children.push(createVNode(tagName, attrs))
+ children.push(createVNode(tagName, attrs, []))
}
return createVNode(Fragment, {}, children)
@@ -139,6 +255,10 @@ function renderToken (this: Renderer, tokens: Token[], idx: number): any {
return createVNode(Fragment, {}, [])
}
+ if (token.tag === '--') {
+ return createVNode(Comment)
+ }
+
return createVNode(token.tag, this.renderAttrs(token) as any, [])
}
@@ -150,7 +270,7 @@ function renderAttrs (this: Renderer, token: Token) {
const result: any = {}
token.attrs.forEach(token => {
- if (attrNameReg.test(token[0])) {
+ if (validateAttrName(token[0])) {
result[token[0]] = token[1]
}
})
@@ -164,6 +284,11 @@ function render (this: Renderer, tokens: Token[], options: any, env: any) {
const vNodeParents: VNode[] = []
return tokens.map((token, i) => {
+ processToken(token, env)
+ if (token.block) {
+ token.attrSet(DOM_ATTR_NAME.TOKEN_IDX, i.toString())
+ }
+
const type = token.type
let vnode: VNode | null = null
@@ -188,8 +313,10 @@ function render (this: Renderer, tokens: Token[], options: any, env: any) {
let isChild = false
const parentNode = vNodeParents.length > 0 ? vNodeParents[vNodeParents.length - 1] : null
if (vnode && parentNode) {
- const children = Array.isArray(parentNode.children) ? parentNode.children : []
- parentNode.children = children.concat([vnode])
+ if (typeof parentNode.type === 'string' || parentNode.type === Fragment) {
+ const children = Array.isArray(parentNode.children) ? parentNode.children : []
+ parentNode.children = children.concat([vnode])
+ }
isChild = true
}
diff --git a/src/renderer/plugins/markdown-run-code.ts b/src/renderer/plugins/markdown-run-code.ts
deleted file mode 100644
index f7f2d3d33..000000000
--- a/src/renderer/plugins/markdown-run-code.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-import { computed, defineComponent, h, onBeforeUnmount, ref, VNode } from 'vue'
-import CryptoJS from 'crypto-js'
-import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { getAction } from '@fe/context/action'
-import * as api from '@fe/support/api'
-import { FLAG_DISABLE_XTERM } from '@fe/support/global-args'
-import storage from '@fe/utils/storage'
-
-const cachePrefix = 'run_code_result_'
-
-const RunCode = defineComponent({
- name: 'run-code',
- props: {
- code: {
- type: String,
- default: ''
- },
- language: String,
- },
- setup (props) {
- const result = ref('')
- const hash = computed(() => CryptoJS.MD5(props.code).toString())
- const id = Date.now()
- let hasResult = false
-
- let appendLog: any = (res: string) => {
- if (hasResult) {
- result.value += '\n' + res
- } else {
- result.value = res
- hasResult = true
- }
-
- storage.set(`${cachePrefix}${hash.value}`, result.value)
- }
-
- const run = async () => {
- const { code, language } = props
-
- hasResult = false
- result.value = '运行中……'
-
- try {
- await api.runCode(language!, code, {
- name: `_l_${id}_${hash.value}`,
- handler: res => appendLog && appendLog(res)
- })
- } catch (error) {
- result.value = error.message
- }
- }
-
- const runInXterm = (e: MouseEvent) => {
- getAction('xterm.run-code')(props.language, props.code, e.ctrlKey)
- }
-
- onBeforeUnmount(() => {
- appendLog = undefined
- })
-
- return () => {
- const runResult = result.value || storage.get(`${cachePrefix}${hash.value}`, '')
-
- return [
- h('div', { class: 'run-code-action', style: 'position: sticky; left: 0; border-top: dashed 1px #888; margin: 1em 0' }, [
- h('div', {
- title: '运行代码',
- style: 'position: absolute; top: -.7em; height: 0; width: 0; border-left: .7em #b7b3b3 solid; border-top: .6em #dddddd00 solid; border-bottom: .6em #dddddd00 solid; border-right: 0; background: rgba(0, 0, 0, 0); cursor: pointer; outline: none',
- onClick: run
- }),
- h('div', {
- title: '在终端中运行代码，Ctrl + 单击不退出解释器',
- class: 'no-print',
- style: 'position: absolute; top: -.5em; right: -0; height: 0; width: 0; border-left: .7em #b7b3b3 solid; border-top: .6em #dddddd00 solid; border-bottom: .6em #dddddd00 solid; border-right: 0; background: rgba(0, 0, 0, 0); cursor: pointer; outline: none;transform: rotate(90deg);',
- onClick: runInXterm
- }),
- ]),
- h('div', { class: 'run-code-result', style: 'padding: .5em 0', innerHTML: runResult }),
- ]
- }
- }
-})
-
-const RunPlugin = (md: Markdown) => {
- const temp = md.renderer.rules.fence!.bind(md.renderer.rules)
- md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
- const token = tokens[idx]
-
- const code = token.content.trim()
- const firstLine = code.split(/\n/)[0].trim()
- if (!firstLine.includes('--run--')) {
- return temp(tokens, idx, options, env, slf)
- }
-
- const codeNode: VNode = temp(tokens, idx, options, env, slf) as any
-
- if (codeNode && Array.isArray(codeNode.children)) {
- codeNode.children.push(h(RunCode, {
- code,
- language: token.info
- }))
- }
-
- return codeNode as any
- }
-}
-
-const clearCache = () => {
- Object.keys(storage.getAll()).forEach(key => {
- if (key.startsWith(cachePrefix)) {
- storage.remove(key)
- }
- })
-}
-
-export default {
- name: 'run-code',
- register: ctx => {
- ctx.theme.addStyles(`
- @media print {
- .markdown-view .markdown-body .run-code-result {
- white-space: pre-wrap;
- }
- }
- `)
-
- ctx.markdown.registerPlugin(RunPlugin)
- ctx.registerHook('ON_STARTUP', clearCache)
-
- !FLAG_DISABLE_XTERM && ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
- editor.addAction({
- id: 'plugin.editor.run-in-xterm',
- label: '终端中运行',
- contextMenuGroupId: 'other',
- precondition: 'editorHasSelection',
- keybindings: [
- monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KEY_R
- ],
- run: () => {
- getAction('xterm.run')(editor.getModel()!.getValueInRange(editor.getSelection()!))
- }
- })
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-source-line.ts b/src/renderer/plugins/markdown-source-line.ts
deleted file mode 100644
index 198f23800..000000000
--- a/src/renderer/plugins/markdown-source-line.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { Plugin } from '@fe/context/plugin'
-import Renderer from 'markdown-it/lib/renderer'
-
-const buildFunction = (className: string): Renderer.RenderRule => {
- return (tokens, idx, options, _, slf) => {
- if (tokens[idx].map) {
- const lineStart = tokens[idx].map![0]
- const lineEnd = tokens[idx].map![1]
- tokens[idx].attrJoin('class', className)
- tokens[idx].attrSet('data-source-line', String(lineStart + 1))
- tokens[idx].attrSet('data-source-line-end', String(lineEnd + 1))
- }
- return slf.renderToken(tokens, idx, options)
- }
-}
-
-export const injectLineNumbers = buildFunction('source-line')
-
-export default {
- name: 'markdown-source-line',
- register: ctx => {
- ctx.markdown.registerPlugin(md => {
- md.renderer.rules.paragraph_open = injectLineNumbers
- md.renderer.rules.heading_open = injectLineNumbers
- md.renderer.rules.list_item_open = injectLineNumbers
- md.renderer.rules.table_open = injectLineNumbers
- md.renderer.rules.td_open = buildFunction('yank-table-cell')
- md.renderer.rules.th_open = buildFunction('yank-table-cell')
- })
- }
-} as Plugin
diff --git a/src/renderer/plugins/markdown-table.ts b/src/renderer/plugins/markdown-table.ts
new file mode 100644
index 000000000..d2d6c904b
--- /dev/null
+++ b/src/renderer/plugins/markdown-table.ts
@@ -0,0 +1,949 @@
+import { nextTick, reactive } from 'vue'
+import Sortable from 'sortablejs'
+import { orderBy } from 'lodash-es'
+import type { Plugin } from '@fe/context'
+import { useModal } from '@fe/support/ui/modal'
+import { hasCtrlCmd } from '@fe/core/keybinding'
+import { DOM_ATTR_NAME, FLAG_READONLY } from '@fe/support/args'
+import { useToast } from '@fe/support/ui/toast'
+import { disableSyncScrollAwhile, renderImmediately } from '@fe/services/view'
+import * as editor from '@fe/services/editor'
+import { t } from '@fe/services/i18n'
+import { getLogger } from '@fe/utils'
+import type Token from 'markdown-it/lib/token'
+import type Renderer from 'markdown-it/lib/renderer'
+import type { Components } from '@fe/types'
+
+const tableSortMode = 'sort-mode'
+const cellClassName = 'yn-table-cell'
+const logger = getLogger('markdown-table')
+
+function editWrapper, U> (fn: (...args: T) => U) {
+ return function (...args: T) {
+ disableSyncScrollAwhile(() => {
+ fn(...args)
+ })
+ }
+}
+
+const getLineContent = editor.getLineContent
+const deleteLine = editWrapper(editor.deleteLine)
+const replaceLine = editWrapper(editor.replaceLine)
+
+function injectClass (tokens: Token[], idx: number, options: any, env: any, slf: Renderer) {
+ const token = tokens[idx]
+ token.attrJoin('class', cellClassName)
+ return slf.renderToken(tokens, idx, options)
+}
+
+function resetInput (input: HTMLTextAreaElement) {
+ input.parentElement!.style.position = ''
+ input.onblur = () => undefined
+ input.remove()
+}
+
+function escapedSplit (str: string) {
+ const result = []
+ const max = str.length
+ let pos = 0
+ let ch = str.charCodeAt(pos)
+ let isEscaped = false
+ let lastPos = 0
+ let current = ''
+
+ while (pos < max) {
+ if (ch === 0x7c/* | */) {
+ if (!isEscaped) {
+ // pipe separating cells, '|'
+ result.push(current + str.substring(lastPos, pos))
+ current = ''
+ lastPos = pos + 1
+ } else {
+ // escaped pipe, '\|'
+ current += str.substring(lastPos, pos - 1)
+ lastPos = pos
+ }
+ }
+
+ isEscaped = (ch === 0x5c/* \ */)
+ pos++
+
+ ch = str.charCodeAt(pos)
+ }
+
+ result.push(current + str.substring(lastPos))
+
+ if (result.length && result[0] === '') result.shift()
+ if (result.length && result[result.length - 1] === '') result.pop()
+
+ return result
+}
+
+function checkLineNumber (start: number, end: number) {
+ if (start >= 0 && end >= 0 && end - start === 1) {
+ return true
+ }
+
+ useToast().show('warning', t('table-cell-edit.limit-single-line'))
+ return false
+}
+
+function columnsToStr (columns: string[], refText: string) {
+ let content = columns.map(value => {
+ if (!value.startsWith(' ')) {
+ value = ' ' + value
+ }
+
+ if (!value.endsWith(' ')) {
+ value += ' '
+ }
+
+ return value.replace(/\|/g, '\\|').replace(/\n/g, ' ')
+ }).join('|').trim()
+
+ refText = refText.trim()
+
+ if (refText.startsWith('|')) content = '| ' + content
+ if (refText.endsWith('|')) content = content + ' |'
+
+ return content
+}
+
+function getCellIndex (td: HTMLTableCellElement) {
+ return [...td.parentElement!.children as any]
+ .slice(0, td.cellIndex)
+ .reduce((prev, current) => prev + current.colSpan, 0)
+}
+
+type Row = { type: 'head' | 'hr' | 'body', start: number, end: number }
+function getRows (td: HTMLTableCellElement): Row[] {
+ let tbody
+ let thead
+ if (td.tagName === 'TD') {
+ tbody = td.parentElement?.parentElement
+ thead = tbody?.previousElementSibling
+ } else if (td.tagName === 'TH') {
+ thead = td.parentElement?.parentElement
+ tbody = thead?.nextElementSibling
+ } else {
+ return []
+ }
+
+ if (!tbody || !thead) {
+ return []
+ }
+
+ const headRows: Row[] = [...thead.children].map(th => {
+ const td = th.children[0] as HTMLElement | undefined
+
+ const start = parseInt(td?.dataset?.sourceLine || '0')
+ const end = parseInt(td?.dataset?.sourceLineEnd || '0')
+
+ return { type: 'head', start, end }
+ })
+
+ if (headRows.length < 1) {
+ return []
+ }
+
+ const bodyRows: Row[] = [...tbody.children].map(tr => {
+ const td = tr.children[0] as HTMLElement | undefined
+
+ const start = parseInt(td?.dataset?.sourceLine || '0')
+ const end = parseInt(td?.dataset?.sourceLineEnd || '0')
+
+ return { type: 'body', start, end }
+ })
+
+ const lastHeadRows = headRows[headRows.length - 1]
+ return headRows.concat([
+ { type: 'hr', start: lastHeadRows.start + 1, end: lastHeadRows.end + 1 }
+ ]).concat(bodyRows)
+}
+
+async function editTableCell (start: number, end: number, cellIndex: number, input: HTMLTextAreaElement | null) {
+ const toast = useToast()
+ const modal = useModal()
+
+ if (!checkLineNumber(start, end)) {
+ input && input.remove()
+ return
+ }
+
+ const text = getLineContent(start)
+
+ const columns = escapedSplit(text)
+ const cellText = columns[cellIndex]?.replace(/^ | $/g, '')
+
+ if (typeof cellText !== 'string') {
+ throw new Error(t('table-cell-edit.edit-error'))
+ }
+
+ let value = cellText
+ let inComposition = false
+ let nextAction: 'edit-next-cell' | 'edit-prev-cell' | 'edit-bellow-cell' | 'edit-above-cell' | undefined
+ let isCancel = false
+
+ if (input) {
+ input.value = cellText
+ input.select()
+ value = await (new Promise((resolve) => {
+ const cancel = () => {
+ resetInput(input)
+ resolve('')
+ isCancel = true
+ }
+
+ const ok = () => {
+ if (input.value !== cellText) {
+ resolve(input.value)
+ resetInput(input)
+ } else {
+ cancel()
+ }
+ }
+
+ input.onblur = ok
+
+ input.onkeydown = e => {
+ if (inComposition) {
+ return
+ }
+
+ if (e.key === 'Escape') {
+ cancel()
+ }
+
+ if (e.key === 'Tab') {
+ nextAction = e.shiftKey ? 'edit-prev-cell' : 'edit-next-cell'
+ ok()
+
+ e.preventDefault()
+ e.stopPropagation()
+ }
+
+ if (e.key === 'Enter') {
+ if (hasCtrlCmd(e) && !e.shiftKey && !e.altKey) {
+ // insert br
+ const startPos = input.selectionStart
+ const endPos = input.selectionEnd
+ input.value = input.value.substring(0, startPos) + '\n' + input.value.substring(endPos)
+ } else if (hasCtrlCmd(e) && e.shiftKey) {
+ const td = input.parentElement as HTMLTableCellElement
+ ok()
+ addRow(td, 1)
+ nextAction = 'edit-bellow-cell'
+ } else if (e.shiftKey) {
+ ok()
+ nextAction = 'edit-above-cell'
+ } else {
+ ok()
+ nextAction = 'edit-bellow-cell'
+ }
+
+ e.preventDefault()
+ e.stopPropagation()
+ }
+ }
+
+ input.addEventListener('compositionstart', () => {
+ inComposition = true
+ })
+
+ input.addEventListener('compositionend', () => {
+ inComposition = false
+ })
+ }))
+ } else {
+ const inputVal = await modal.input({
+ title: t('table-cell-edit.edit-title'),
+ type: 'textarea',
+ value: cellText,
+ modalWidth: '600px',
+ hint: t('table-cell-edit.edit-hint'),
+ })
+
+ if (typeof inputVal !== 'string') {
+ toast.show('warning', t('table-cell-edit.canceled'))
+ isCancel = true
+ }
+
+ value = inputVal || ''
+ }
+
+ if (!isCancel) {
+ if (!value.startsWith(' ') && cellIndex > 0) value = ' ' + value
+ if (!value.endsWith(' ') && cellIndex < columns.length - 1) value += ' '
+
+ columns[cellIndex] = value
+
+ replaceLine(start, columnsToStr(columns, text))
+ }
+
+ return nextAction
+}
+
+async function handleClick (e: MouseEvent, modal: boolean) {
+ if (FLAG_READONLY) {
+ return
+ }
+
+ const target = e.target as HTMLElement
+
+ const preventEvent = () => {
+ e.preventDefault()
+ e.stopPropagation()
+ return true
+ }
+
+ if (['TD', 'TH'].includes(target.tagName) && target.classList.contains(cellClassName)) {
+ if ((hasCtrlCmd(e) && !modal) || (!hasCtrlCmd(e) && e.type !== 'contextmenu' && modal)) {
+ return false
+ }
+
+ const handleEditTableCell = (td: HTMLTableCellElement) => {
+ const start = parseInt(td.dataset.sourceLine || '0')
+ const end = parseInt(td.dataset.sourceLineEnd || '0')
+ const cellIndex = getCellIndex(td)
+ const input = modal ? null : document.createElement('textarea')
+
+ if (input) {
+ td.style.position = 'relative'
+ input.style.left = '0'
+ input.style.top = '0'
+ input.style.height = '100%'
+ input.style.width = '100%'
+ input.style.boxSizing = 'border-box'
+ input.style.color = 'var(--g-color-0)'
+ input.style.border = '1px #93e632 solid'
+ input.style.backgroundColor = 'var(--g-color-96)'
+ input.style.fontSize = '13px'
+ input.style.position = 'absolute'
+ input.style.display = 'block'
+ input.style.padding = '3px'
+ input.style.lineHeight = '1.2'
+ ;(input as any).autofocus = true
+ input.placeholder = t('table-cell-edit.esc-to-cancel')
+ setTimeout(() => {
+ input.focus()
+ }, 0)
+
+ td.appendChild(input)
+ }
+
+ editTableCell(start, end, cellIndex, input).catch((e: Error) => {
+ useToast().show('warning', e.message)
+ input && resetInput(input)
+ }).then(nextAction => {
+ if (nextAction) {
+ setTimeout(() => {
+ if (nextAction === 'edit-next-cell' && td.nextElementSibling) {
+ handleEditTableCell(td.nextElementSibling as HTMLTableCellElement)
+ } else if (nextAction === 'edit-prev-cell' && td.previousElementSibling) {
+ handleEditTableCell(td.previousElementSibling as HTMLTableCellElement)
+ } else if (nextAction === 'edit-bellow-cell') {
+ const tr = td.parentElement?.nextElementSibling
+ if (tr && tr.tagName === 'TR') {
+ const nextTd = tr.children[cellIndex] as HTMLTableCellElement
+ if (nextTd && (nextTd.tagName === 'TD' || nextTd.tagName === 'TH')) {
+ handleEditTableCell(nextTd)
+ }
+ }
+ } else if (nextAction === 'edit-above-cell') {
+ const tr = td.parentElement?.previousElementSibling
+ if (tr && tr.tagName === 'TR') {
+ const nextTd = tr.children[cellIndex] as HTMLTableCellElement
+ if (nextTd && (nextTd.tagName === 'TD' || nextTd.tagName === 'TH')) {
+ handleEditTableCell(nextTd)
+ }
+ }
+ }
+ }, 0)
+ }
+ })
+ }
+
+ handleEditTableCell(target as HTMLTableCellElement)
+
+ return preventEvent()
+ }
+
+ return false
+}
+
+function addRow (td: HTMLTableCellElement, num: number) {
+ const start = parseInt(td.dataset.sourceLine || '0')
+ const end = parseInt(td.dataset.sourceLineEnd || '0')
+
+ if (!checkLineNumber(start, end)) {
+ return
+ }
+
+ const rows = getRows(td)
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const refText = getLineContent(hr.start)
+ const cols = escapedSplit(refText)
+ const columns = cols.map((str) => str.replace(/\S/g, '-'))
+
+ const str = columnsToStr(columns, refText)
+
+ const strs = Array.from({ length: Math.abs(num) }, () => str).join('\n')
+
+ const content = getLineContent(start)
+ const text = num > 0 ? `${content}\n${strs}` : `${strs}\n${content}`
+
+ replaceLine(start, text)
+}
+
+function deleteRow (td: HTMLTableCellElement) {
+ const start = parseInt(td.dataset.sourceLine || '0')
+ const end = parseInt(td.dataset.sourceLineEnd || '0')
+
+ if (!checkLineNumber(start, end)) {
+ return
+ }
+
+ deleteLine(start)
+}
+
+function processColumns (td: HTMLTableCellElement, process: (columns: string[]) => void) {
+ const rows = getRows(td)
+ if (rows.some(({ start, end }) => !checkLineNumber(start, end))) {
+ return
+ }
+
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const refText = getLineContent(hr.start)
+
+ const _editor = editor.getEditor()
+ const monaco = editor.getMonaco()
+
+ const _replaceLine = editWrapper((line: number, text: string) => {
+ const length = editor.getEditor().getModel()!.getLineLength(line)
+ _editor.executeEdits('', [
+ {
+ range: new (monaco.Range)(line, 1, line, length + 1),
+ text,
+ forceMoveMarkers: true
+ }
+ ])
+ _editor.setPosition(new monaco.Position(line, text.length + 1))
+ })
+
+ rows.forEach((row) => {
+ const { start } = row
+
+ const content = getLineContent(start)
+ const columns = escapedSplit(content)
+
+ process(columns)
+
+ _replaceLine(start, columnsToStr(columns, refText))
+ })
+
+ _editor.focus()
+}
+
+function alignCol (td: HTMLTableCellElement, type: 'left' | 'center' | 'right' | 'normal') {
+ const rows = getRows(td)
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const content = getLineContent(hr.start)
+ const columns = escapedSplit(content)
+ const cellIndex = getCellIndex(td)
+
+ let val = (columns[cellIndex] || '').replace(/^\s*:*|:*\s*$/g, '')
+
+ switch (type) {
+ case 'left':
+ val = ':' + val
+ break
+ case 'center':
+ val = ':' + val + ':'
+ break
+ case 'right':
+ val = val + ':'
+ break
+ }
+
+ columns[cellIndex] = ` ${val} `
+ replaceLine(hr.start, columnsToStr(columns, content))
+}
+
+function addCol (td: HTMLTableCellElement, num: number) {
+ const offset = num > 0 ? 1 : 0
+ const cellIndex = getCellIndex(td)
+ const arr = Array.from({ length: Math.abs(num) }, () => ' -- ')
+
+ processColumns(td, columns => {
+ if (cellIndex > columns.length - 1 || cellIndex < 0) {
+ return
+ }
+
+ columns.splice(cellIndex + offset, 0, ...arr)
+ })
+}
+
+function deleteCol (td: HTMLTableCellElement) {
+ const cellIndex = getCellIndex(td)
+ processColumns(td, columns => {
+ columns.splice(cellIndex, 1)
+ })
+}
+
+function sortCol (td: HTMLTableCellElement, oldIndex: number, newIndex: number) {
+ processColumns(td, columns => {
+ if (columns.length - 1 < Math.max(oldIndex, newIndex)) {
+ return
+ }
+
+ const text = columns[oldIndex]
+ columns.splice(oldIndex, 1)
+ columns.splice(newIndex, 0, text)
+ })
+}
+
+function sortRow (td: HTMLTableCellElement, oldIndex: number, newIndex: number) {
+ const rows = orderBy(getRows(td).filter(x => x.type === 'body'), x => x.start)
+ if (rows.length - 1 < Math.max(oldIndex, newIndex)) {
+ return
+ }
+
+ if (rows.some(({ start, end }) => !checkLineNumber(start, end))) {
+ return
+ }
+
+ const oldLine = rows[oldIndex].start
+ const newLine = rows[newIndex].start
+
+ const content = getLineContent(oldLine)
+ deleteLine(oldLine)
+ const prevContent = getLineContent(newLine)
+ replaceLine(newLine, `${content}\n${prevContent}`)
+}
+
+function toggleSortMode (td: HTMLTableCellElement, flag: boolean) {
+ const table: (HTMLElement & { colSortable?: Sortable, rowSortable?: Sortable }) | null | undefined = td.parentElement?.parentElement?.parentElement
+ if (!table || table.tagName !== 'TABLE') {
+ return
+ }
+
+ logger.debug('toggleSortMode', flag)
+
+ const theadFirstTr = table.querySelector('thead > tr')
+ const tbody = table.querySelector('tbody')
+
+ const clean = () => {
+ logger.debug('toggleSortMode', 'clean')
+ table.onblur = null
+ table.onkeydown = null
+ table.removeAttribute(tableSortMode)
+ table.colSortable?.destroy()
+ delete table.colSortable
+ table.rowSortable?.destroy()
+ table.blur()
+ delete table.rowSortable
+ }
+
+ if (flag && theadFirstTr && tbody) {
+ clean()
+
+ // restore origin order for vue vnode
+ const restoreOrder = (sortable: Sortable, oldIndex: number, newIndex: number) => {
+ const arr = sortable.toArray()
+ const id = arr[newIndex]
+ arr.splice(newIndex, 1)
+ arr.splice(oldIndex, 0, id)
+ sortable.sort(arr)
+ }
+
+ table.colSortable = Sortable.create(theadFirstTr, {
+ animation: 200,
+ direction: 'horizontal',
+ dataIdAttr: DOM_ATTR_NAME.TOKEN_IDX,
+ onEnd: ({ oldIndex, newIndex }) => {
+ if (typeof oldIndex === 'number' && typeof newIndex === 'number' && oldIndex !== newIndex) {
+ restoreOrder(table.colSortable!, oldIndex, newIndex)
+ sortCol(td, oldIndex, newIndex)
+ renderImmediately()
+ nextTick(() => toggleSortMode(td, true))
+ }
+ }
+ })
+
+ table.rowSortable = Sortable.create(tbody, {
+ animation: 200,
+ direction: 'vertical',
+ handle: 'td:first-of-type',
+ dataIdAttr: DOM_ATTR_NAME.TOKEN_IDX,
+ onEnd: ({ oldIndex, newIndex }) => {
+ if (typeof oldIndex === 'number' && typeof newIndex === 'number' && oldIndex !== newIndex) {
+ restoreOrder(table.rowSortable!, oldIndex, newIndex)
+ sortRow(td, oldIndex, newIndex)
+ renderImmediately()
+ nextTick(() => toggleSortMode(td, true))
+ }
+ }
+ })
+
+ table.tabIndex = -1
+
+ table.onblur = () => {
+ toggleSortMode(td, false)
+ }
+
+ table.onkeydown = (e) => {
+ if (e.key === 'Escape') {
+ toggleSortMode(td, false)
+ }
+ }
+
+ table.setAttribute(tableSortMode, 'true')
+ table.focus()
+ } else {
+ clean()
+ }
+}
+
+function sortRows (td: HTMLTableCellElement, order: 'asc' | 'desc') {
+ const rows = getRows(td).filter(x => x.type === 'body')
+ const cellIndex = getCellIndex(td)
+ const contents = rows.map(row => {
+ const text = getLineContent(row.start)
+ return {
+ sortBy: escapedSplit(text)[cellIndex],
+ text,
+ }
+ })
+
+ orderBy(contents, x => {
+ const number = parseFloat(x.sortBy)
+ if (!isNaN(number) && isFinite(number)) {
+ return number.toFixed(12).padStart(20) + x.sortBy
+ }
+
+ return x.sortBy
+ }, order).forEach(({ text }, i) => {
+ replaceLine(rows[i].start, text)
+ })
+}
+
+const insertNums = reactive({
+ colLeft: 1,
+ colRight: 1,
+ rowTop: 1,
+ rowBottom: 1,
+})
+
+export default {
+ name: 'markdown-table',
+ register: (ctx) => {
+ ctx.view.addStyles(`
+ .markdown-view .markdown-body table.small td,
+ .markdown-view .markdown-body table.small th {
+ padding: 3px 6px;
+ font-size: 14px;
+ line-height: 1.3;
+ }
+
+ @media screen {
+ .markdown-view .markdown-body .table-wrapper {
+ overflow-x: auto;
+ margin-bottom: 16px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table {
+ margin-bottom: 6px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tr {
+ scroll-margin: 2px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table th {
+ white-space: nowrap;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table td:hover,
+ .markdown-view .markdown-body .table-wrapper > table th:hover {
+ background: var(--g-color-85);
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tr:hover {
+ outline: 1px #b3833b dashed;
+ outline-offset: -1px;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tbody {
+ counter-reset: tr-number;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table tbody:hover td:first-child:before {
+ counter-increment: tr-number;
+ content: counter(tr-number);
+ position: absolute;
+ right: 100%;
+ padding-right: 5px;
+ color: #999;
+ font-family: monospace;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode],
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] tr {
+ outline: none;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] td:hover,
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] th:hover {
+ background: initial;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] thead tr:first-of-type th {
+ background: var(--g-color-86);
+ cursor: ew-resize;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] tbody tr td:first-of-type {
+ background: var(--g-color-86);
+ cursor: ns-resize;
+ }
+
+ .markdown-view .markdown-body .table-wrapper > table[sort-mode] .sortable-ghost {
+ opacity: 0.5;
+ }
+ }
+ `)
+
+ ctx.theme.addStyles(`
+ .plugin-table-cell-edit-insert-nums {
+ display: flex;
+ align-items: center;
+ }
+
+ .plugin-table-cell-edit-insert-nums > input {
+ margin-left: 10px !important;
+ font-size: 12px !important;
+ padding: 0 2px !important;
+ width: 3em !important;
+ text-align: center !important;
+ background: rgba(var(--g-color-0-rgb), 0.1) !important;
+ margin-top: -4px !important;
+ margin-bottom: -4px !important;
+ }
+ `)
+
+ ctx.markdown.registerPlugin(md => {
+ md.renderer.rules.table_open = (tokens, idx, options, _, slf) => {
+ const table = slf.renderToken(tokens, idx, options)
+ return {
+ node: ctx.lib.vue.h('div', {
+ class: 'table-wrapper'
+ }, table),
+ parent: table
+ } as any
+ }
+
+ md.renderer.rules.td_open = injectClass
+ md.renderer.rules.th_open = injectClass
+ })
+
+ ctx.registerHook('VIEW_ELEMENT_DBCLICK', ({ e }) => handleClick(e, false))
+ ctx.registerHook('VIEW_ELEMENT_CLICK', ({ e }) => handleClick(e, true))
+ ctx.registerHook('VIEW_RENDERED', () => {
+ if (ctx.args.FLAG_READONLY) {
+ return
+ }
+
+ const view = ctx.view.getViewDom()
+ view?.querySelectorAll('.yank-table-cell').forEach(td => {
+ (td as HTMLElement).title = t('table-cell-edit.db-click-edit')
+ })
+ })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node }) => {
+ // remove table style: width, height
+ if (node.tagName === 'TABLE') {
+ node.style.width = ''
+ node.style.height = ''
+ }
+ })
+
+ ctx.view.tapContextMenus((menus, e) => {
+ if (ctx.args.FLAG_READONLY) {
+ return
+ }
+
+ const target = e.target as HTMLTableCellElement
+ const tagName = target.tagName
+ if ((tagName === 'TD' || tagName === 'TH') && target.classList.contains(cellClassName)) {
+ const rows = getRows(target)
+ const hr = rows.find(x => x.type === 'hr')
+ if (!hr) {
+ return
+ }
+
+ const columns = escapedSplit(ctx.editor.getLineContent(hr.start))
+ const cellIndex = getCellIndex(target)
+ const styleText = (columns[cellIndex] || '').trim()
+
+ if (!styleText) {
+ const msg = 'Incorrect table format'
+ ctx.ui.useToast().show('warning', msg)
+ throw new Error(msg)
+ }
+
+ const buildInput = (key: keyof typeof insertNums) => ctx.lib.vue.h('input', {
+ value: insertNums[key],
+ type: 'number',
+ min: 1,
+ max: 99,
+ step: 1,
+ onInput: (e: any) => { insertNums[key] = e.target.value },
+ onClick: (e: any) => { e.stopPropagation() },
+ onKeyup: (e: any) => { if (e.keyCode === 13) { e.target.parentNode.click(); e.stopPropagation() } }
+ })
+
+ const editRowMenu: Components.ContextMenu.Item[] = tagName === 'TD' ? [
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.add-row-above',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-row-above'),
+ buildInput('rowTop')
+ ]),
+ onClick: () => addRow(target, -(insertNums.rowTop || 1)),
+ },
+ {
+ id: 'plugin.table.cell-edit.add-row-below',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-row-below'),
+ buildInput('rowBottom')
+ ]),
+ onClick: () => addRow(target, insertNums.rowBottom || 1),
+ },
+ {
+ id: 'plugin.table.cell-edit.delete-row',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.delete-row'),
+ hidden: rows.length < 4,
+ onClick: () => deleteRow(target)
+ },
+ ] : []
+
+ menus.push(
+ {
+ id: 'plugin.table.cell-edit.quick-edit',
+ type: 'normal' as any,
+ label: ctx.i18n.t('table-cell-edit.context-menu.quick-edit'),
+ onClick: () => {
+ handleClick(e, false)
+ }
+ },
+ {
+ id: 'plugin.table.cell-edit.edit',
+ type: 'normal' as any,
+ label: ctx.i18n.t('table-cell-edit.context-menu.edit'),
+ ellipsis: true,
+ onClick: () => {
+ handleClick(e, true)
+ }
+ },
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.sort-mode',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.sort-mode'),
+ onClick: () => {
+ toggleSortMode(target, true)
+ }
+ },
+ {
+ id: 'plugin.table.cell-edit.sort-asc',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.sort-asc'),
+ onClick: () => {
+ sortRows(target, 'asc')
+ }
+ },
+ {
+ id: 'plugin.table.cell-edit.sort-desc',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.sort-desc'),
+ onClick: () => {
+ sortRows(target, 'desc')
+ }
+ },
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.align-left',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-left'),
+ hidden: /^:[^:]*$/.test(styleText),
+ onClick: () => alignCol(target, 'left'),
+ },
+ {
+ id: 'plugin.table.cell-edit.align-center',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-center'),
+ hidden: /^:[^:]*:$/.test(styleText),
+ onClick: () => alignCol(target, 'center'),
+ },
+ {
+ id: 'plugin.table.cell-edit.align-right',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-right'),
+ hidden: /^[^:]*:$/.test(styleText),
+ onClick: () => alignCol(target, 'right'),
+ },
+ {
+ id: 'plugin.table.cell-edit.align-normal',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.align-normal'),
+ hidden: /^[^:]*$/.test(styleText),
+ onClick: () => alignCol(target, 'normal'),
+ },
+ ...editRowMenu,
+ { type: 'separator' },
+ {
+ id: 'plugin.table.cell-edit.add-col-left',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-col-left'),
+ buildInput('colLeft')
+ ]),
+ onClick: () => addCol(target, -(insertNums.colLeft || 1))
+ },
+ {
+ id: 'plugin.table.cell-edit.add-col-right',
+ type: 'normal',
+ label: ctx.lib.vue.h('span', { class: 'plugin-table-cell-edit-insert-nums' }, [
+ ctx.i18n.t('table-cell-edit.context-menu.add-col-right'),
+ buildInput('colRight')
+ ]),
+ onClick: () => addCol(target, insertNums.colRight || 1)
+ },
+ {
+ id: 'plugin.table.cell-edit.delete-col',
+ type: 'normal',
+ label: ctx.i18n.t('table-cell-edit.context-menu.delete-col'),
+ hidden: columns.length < 2,
+ onClick: () => deleteCol(target)
+ },
+ )
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-task-list.ts b/src/renderer/plugins/markdown-task-list.ts
index cc6426bf4..33e8cccd6 100644
--- a/src/renderer/plugins/markdown-task-list.ts
+++ b/src/renderer/plugins/markdown-task-list.ts
@@ -7,8 +7,10 @@
// https://github.com/blog/1375-task-lists-in-gfm-issues-pulls-comments
// https://github.com/blog/1825-task-lists-in-all-markdown-documents
+import { h } from 'vue'
import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
+import { Plugin } from '@fe/context'
+import { DOM_CLASS_NAME } from '@fe/support/args'
let disableCheckboxes = true
@@ -67,12 +69,22 @@ function todoify (token: { children: any[]; content: string | any[] }, TokenCons
function makeCheckbox (token: { content: string | string[] }, TokenConstructor: new (arg0: string, arg1: string, arg2: number) => any) {
const checkbox = new TokenConstructor('html_inline', '', 0)
- const disabledAttr = disableCheckboxes ? ' disabled="" ' : ' '
+
+ const props = {
+ class: DOM_CLASS_NAME.TASK_LIST_ITEM_CHECKBOX,
+ type: 'checkbox',
+ disabled: disableCheckboxes,
+ }
+
if (token.content.indexOf('[ ] ') === 0) {
- checkbox.content = ''
+ const checked = false
+ checkbox.contentVNode = h('input', { ...props, checked, 'data-checked': String(checked) })
} else if (token.content.indexOf('[x] ') === 0 || token.content.indexOf('[X] ') === 0) {
- checkbox.content = ''
+ const checked = true
+ checkbox.contentVNode = h('input', { ...props, checked, 'data-checked': String(checked) })
}
+
+ checkbox.content = token.content
return checkbox
}
@@ -89,5 +101,16 @@ export default {
name: 'markdown-task-list',
register: ctx => {
ctx.markdown.registerPlugin(MarkdownItPlugin, { enabled: true })
+
+ ctx.registerHook('VIEW_ON_GET_HTML_FILTER_NODE', ({ node }) => {
+ if (node.classList.contains(DOM_CLASS_NAME.TASK_LIST_ITEM_CHECKBOX)) {
+ node.setAttribute('disabled', 'disabled')
+ if (node.dataset.checked === 'true') {
+ node.setAttribute('checked', 'checked')
+ } else {
+ node.removeAttribute('checked')
+ }
+ }
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-toc.ts b/src/renderer/plugins/markdown-toc.ts
index 0278b61a3..837c0b809 100644
--- a/src/renderer/plugins/markdown-toc.ts
+++ b/src/renderer/plugins/markdown-toc.ts
@@ -1,13 +1,12 @@
// https://github.com/Oktavilla/markdown-it-table-of-contents
+import { h } from 'vue'
import Markdown from 'markdown-it'
import StateInline from 'markdown-it/lib/rules_inline/state_inline'
-import { getKeyLabel } from '@fe/context/shortcut'
-import { Plugin } from '@fe/context/plugin'
+import { getKeyLabel } from '@fe/core/keybinding'
+import ctx, { Plugin } from '@fe/context'
-import { injectLineNumbers } from './markdown-source-line'
-
-const slugify = (s: string) => 'h-' + encodeURIComponent(String(s).trim().toLowerCase().replace(/\s+/g, '-'))
+const slugify = (s: string) => String(s).trim().replace(/\s+/g, '-')
const defaults = {
level: [2, 3],
@@ -24,7 +23,7 @@ const defaults = {
const MarkdownItPlugin = (md: Markdown, o: any) => {
const options = Object.assign({}, defaults, o)
const tocRegexp = options.markerPattern
- let gstate: any
+ let gTokens: any[]
function toc (state: StateInline, silent: any) {
let match
@@ -45,12 +44,12 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
return false
}
- if (match.length > 1) { // 有自定义参数进来
+ if (match.length > 1) { // custom params.
try {
const ext = JSON.parse(match[1].replace(/(['"])?([a-z0-9A-Z_]+)(['"])?:/g, '"$2": '))
Object.assign(options, defaults, o, ext)
} catch (error) {
- console.log('参数解析错误', match)
+ console.log('parse params error', match)
}
} else {
Object.assign(options, defaults, o)
@@ -109,12 +108,14 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
}
}
- // 给标题加上 id
+ // Add id to heading.
const slug = options.slugify(heading.content)
- buffer = ``
- buffer += typeof options.format === 'function' ? options.format(heading.content) : heading.content
+ buffer = ``
+ buffer += typeof options.format === 'function'
+ ? options.format(heading.content)
+ : heading.content.replaceAll('<', '<').replaceAll('>', '>')
buffer += ''
i++
}
@@ -124,6 +125,10 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
}
md.renderer.rules.toc_body = function () {
+ if (!gTokens) {
+ return
+ }
+
let tocBody = ''
if (options.forceFullToc) {
@@ -143,24 +148,28 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
*/
let pos = 0
- const tokenLength = gstate && gstate.tokens && gstate.tokens.length
+ const tokenLength = gTokens.length
while (pos < tokenLength) {
- const tocHierarchy = renderChildrenTokens(pos, gstate.tokens)
+ const tocHierarchy = renderChildrenTokens(pos, gTokens)
pos = tocHierarchy[0]
tocBody += tocHierarchy[1]
}
} else {
- tocBody = renderChildrenTokens(0, gstate.tokens)[1]
+ tocBody = renderChildrenTokens(0, gTokens)[1]
}
- return ``
+ const html = `
+ ${options.containerHeaderHtml}
+ ${tocBody}
+ ${options.containerFooterHtml}
+ `
+
+ return h('div', { key: html, class: options.containerClass, innerHTML: html }) as any
}
+ const headTitle = getKeyLabel('CtrlCmd') + ' + ' + ctx.i18n.t('click-to-copy-link')
+
md.renderer.rules.heading_open = function (tokens, idx, opt, env, slf) {
const header = tokens[idx]
const headContent = tokens[idx + 1]
@@ -171,15 +180,22 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
}
if (header.attrIndex('title') < 0) {
- header.attrSet('title', getKeyLabel('CtrlCmd') + ' + 单击复制链接')
+ header.attrSet('title', headTitle)
}
- return injectLineNumbers(tokens, idx, opt, env, slf)
+ header.attrSet('data-tag', header.tag)
+
+ return slf.renderToken(tokens, idx, opt)
}
// Catch all the tokens for iteration later
md.core.ruler.push('grab_state', function (state) {
- gstate = state
+ // only heading close and heading content
+ const maxIdx = state.tokens.length - 1
+ gTokens = state.tokens.filter((token: any, i: number, arr: any[]) => {
+ return token.type === 'heading_close' ||
+ (i < maxIdx && arr[i + 1].type === 'heading_close' && token.type === 'inline')
+ })
return true
})
@@ -190,7 +206,7 @@ const MarkdownItPlugin = (md: Markdown, o: any) => {
export default {
name: 'markdown-toc',
register: ctx => {
- ctx.theme.addStyles(`
+ ctx.view.addStyles(`
.markdown-view .markdown-body .table-of-contents ol {
counter-reset: ol-number;
list-style-type: none;
@@ -211,6 +227,15 @@ export default {
content: counter(ol-number) ". ";
}
`)
+
ctx.markdown.registerPlugin(MarkdownItPlugin)
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ /* eslint-disable no-template-curly-in-string */
+
+ items.push(
+ { language: 'markdown', label: '/ [toc] Table of content', insertText: '[toc]{type: "${1|ul,ol|}", level: [2,3]}', block: true },
+ )
+ })
}
} as Plugin
diff --git a/src/renderer/plugins/markdown-wiki-links/index.ts b/src/renderer/plugins/markdown-wiki-links/index.ts
new file mode 100644
index 000000000..0a609c545
--- /dev/null
+++ b/src/renderer/plugins/markdown-wiki-links/index.ts
@@ -0,0 +1,77 @@
+import { Plugin } from '@fe/context'
+import { RULE_NAME, wikiLinks } from './lib'
+import workerIndexerUrl from './worker-indexer?worker&url'
+
+export default {
+ name: 'markdown-wiki-links',
+ register: ctx => {
+ ctx.markdown.registerPlugin(md => {
+ md.inline.ruler.after('link', RULE_NAME, wikiLinks)
+ })
+
+ ctx.editor.whenEditorReady().then(({ editor, monaco }) => {
+ editor.onDidChangeCursorPosition(async e => {
+ // debugger
+ if (e.source === 'keyboard' && e.reason === 0) {
+ // delay to next tick to avoid issue on Windows
+ await ctx.utils.sleep(0)
+
+ const prevStr = editor.getModel()!.getValueInRange({
+ startLineNumber: e.position.lineNumber,
+ startColumn: e.position.column - 2,
+ endLineNumber: e.position.lineNumber,
+ endColumn: e.position.column,
+ })
+
+ const nextStr = editor.getModel()!.getValueInRange({
+ startLineNumber: e.position.lineNumber,
+ startColumn: e.position.column,
+ endLineNumber: e.position.lineNumber,
+ endColumn: e.position.column + 2,
+ })
+
+ if (prevStr === '【【') {
+ // replace 【【 to [[]]
+ editor.pushUndoStop()
+ editor.executeEdits(RULE_NAME, [{
+ range: {
+ startLineNumber: e.position.lineNumber,
+ startColumn: e.position.column - 2,
+ endLineNumber: e.position.lineNumber,
+ endColumn: e.position.column + (nextStr === '】】' ? 2 : 0),
+ },
+ text: '[[]]',
+ }], [
+ new monaco.Selection(
+ e.position.lineNumber,
+ e.position.column,
+ e.position.lineNumber,
+ e.position.column,
+ ),
+ ])
+ editor.pushUndoStop()
+
+ // trigger completion
+ editor.trigger(RULE_NAME, 'editor.action.triggerSuggest', {})
+ }
+ }
+ })
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ items.push(
+ { language: 'markdown', label: '/ [[]] Wiki Link', insertText: '[[$1]]', command: { id: 'editor.action.triggerSuggest', title: '' } },
+ )
+ })
+
+ ctx.indexer.importScriptsToWorker(new URL(workerIndexerUrl, import.meta.url))
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys }) => {
+ if (changedKeys.includes('render.md-wiki-links')) {
+ ctx.indexer.rebuildCurrentRepo()
+ }
+ })
+
+ return { mdRuleWikiLinks: wikiLinks }
+ }
+} satisfies Plugin
diff --git a/src/renderer/plugins/markdown-wiki-links/lib.ts b/src/renderer/plugins/markdown-wiki-links/lib.ts
new file mode 100644
index 000000000..dc26f04f4
--- /dev/null
+++ b/src/renderer/plugins/markdown-wiki-links/lib.ts
@@ -0,0 +1,90 @@
+import { DOM_ATTR_NAME } from '@fe/support/args'
+import type StateInline from 'markdown-it/lib/rules_inline/state_inline'
+
+const reMatch = /^([^[#|]*)?(?:#([^#|]*))?(?:\|([^\]]*))?$/
+const reExternalLink = /^[a-zA-Z]{1,8}:\/\/.*/
+const rePos = /(:\d{1,6},?\d{0,6})$/
+
+export const RULE_NAME = 'wiki-links'
+
+export function wikiLinks (state: StateInline, silent?: boolean) {
+ const isImage = state.src.charCodeAt(state.pos) === 0x21/* ! */
+
+ const offset = isImage
+ ? 3 // ![[
+ : 2 // [[
+
+ // check [[
+ if (state.src.charCodeAt(state.pos + offset - 2) !== 0x5B/* [ */ || state.src.charCodeAt(state.pos + offset - 1) !== 0x5B/* [ */) {
+ return false
+ }
+
+ const endPos = state.src.indexOf(']]', state.pos + offset)
+ if (endPos === -1 || endPos === state.pos + offset) {
+ return false
+ }
+
+ const content = state.src.slice(state.pos + offset, endPos)
+ const parts = content.match(reMatch)
+ if (!parts) {
+ return false
+ }
+
+ let link = (parts[1] || '').trim()
+ const hash = parts[2] || ''
+ const label = parts[3] || ''
+
+ const hashStr = hash ? `#${hash}` : ''
+
+ let url = link + hashStr
+ let text = label || url
+ let isAnchor = false
+
+ // internal link
+ if (!reExternalLink.test(link)) {
+ let posStr = ''
+ const posMatch = link.match(rePos)
+ if (posMatch) {
+ link = link.replace(rePos, '')
+ posStr = posMatch[1]
+ }
+
+ const fileName = link.split('/').pop()
+ text = label || (fileName ? (fileName + posStr + hashStr) : url)
+
+ if (!link) {
+ url = posStr + hashStr
+ text = label || hash || url
+ isAnchor = true
+ }
+ }
+
+ if (!silent) {
+ if (isImage) {
+ const attrs: [string, string][] = [
+ ['src', url],
+ [DOM_ATTR_NAME.WIKI_RESOURCE, 'true'],
+ ['alt', text],
+ ]
+
+ state.push('image', 'img', 0).attrs = attrs
+ } else {
+ const attrs: [string, string][] = [
+ ['href', url],
+ [DOM_ATTR_NAME.WIKI_LINK, 'true'],
+ ]
+
+ if (isAnchor) {
+ attrs.push([DOM_ATTR_NAME.IS_ANCHOR, 'true'])
+ }
+
+ state.push('link_open', 'a', 1).attrs = attrs
+ state.push('text', '', 0).content = text
+ state.push('link_close', 'a', -1)
+ }
+ }
+
+ state.pos = endPos + 2 // ]]
+
+ return true
+}
diff --git a/src/renderer/plugins/markdown-wiki-links/worker-indexer.ts b/src/renderer/plugins/markdown-wiki-links/worker-indexer.ts
new file mode 100644
index 000000000..10fab376e
--- /dev/null
+++ b/src/renderer/plugins/markdown-wiki-links/worker-indexer.ts
@@ -0,0 +1,18 @@
+import { RULE_NAME, wikiLinks } from './lib'
+import type { IndexerWorkerCtx } from '@fe/others/indexer-worker'
+
+const ctx: IndexerWorkerCtx = self.ctx
+
+ctx.markdown.use(md => {
+ md.inline.ruler.after('link', RULE_NAME, wikiLinks)
+})
+
+ctx.registerHook('WORKER_INDEXER_BEFORE_START_WATCH', async () => {
+ const enableWikiLinks = await ctx.bridgeClient.call.ctx.setting.getSetting('render.md-wiki-links', true as any)
+
+ if (enableWikiLinks) {
+ ctx.markdown.enable([RULE_NAME], true)
+ } else {
+ ctx.markdown.disable([RULE_NAME], true)
+ }
+})
diff --git a/src/renderer/plugins/media-player.ts b/src/renderer/plugins/media-player.ts
new file mode 100644
index 000000000..341900f91
--- /dev/null
+++ b/src/renderer/plugins/media-player.ts
@@ -0,0 +1,128 @@
+import { defineComponent, h, ref, watchEffect } from 'vue'
+import mime from 'mime'
+import type { Plugin } from '@fe/context'
+import store from '@fe/support/store'
+import { getAttachmentURL } from '@fe/services/base'
+import { sleep } from '@fe/utils'
+import type { Doc } from '@fe/types'
+
+import { isElectron } from '@fe/support/env'
+
+function isMediaFile (doc?: Doc | null): 'video' | 'audio' | false {
+ if (!doc) {
+ return false
+ }
+
+ if (doc.plain) {
+ return false
+ }
+
+ const fileMime = mime.getType(doc.name)
+ if (!fileMime) {
+ return false
+ }
+
+ if (fileMime.startsWith('video/')) {
+ return 'video'
+ }
+
+ if (fileMime.startsWith('audio/')) {
+ return 'audio'
+ }
+
+ return false
+}
+
+const MediaPlayer = defineComponent({
+ setup () {
+ const src = ref('')
+ const type = ref<'video' | 'audio' | false>(false)
+
+ watchEffect(async () => {
+ const doc = store.state.currentFile
+ type.value = false
+ src.value = ''
+ await sleep(0)
+
+ if (doc) {
+ type.value = isMediaFile(doc)
+
+ if (isElectron && doc.absolutePath) {
+ src.value = 'file://' + doc.absolutePath
+ } else {
+ src.value = getAttachmentURL(doc)
+ }
+ }
+ })
+
+ function onLeavepictureinpicture (e: Event) {
+ const target = e.target as HTMLMediaElement
+ if (!target.isConnected) {
+ target.pause()
+ }
+ }
+
+ return () => src.value ? h(
+ 'div',
+ { style: 'width: 100%; height: 100%; display: flex; align-items: center; justify-content: center' },
+ type.value === 'video'
+ ? h('video', { src: src.value, controls: true, onLeavepictureinpicture, style: 'width: 100%; height: 100%; object-fit: contain' })
+ : type.value === 'audio'
+ ? h('audio', { src: src.value, controls: true })
+ : ''
+ ) : null
+ }
+})
+
+export default {
+ name: 'media-player',
+ register: ctx => {
+ ctx.editor.registerCustomEditor({
+ name: 'image-player',
+ displayName: 'Image Viewer',
+ hiddenPreview: true,
+ when ({ doc }) {
+ return !!isMediaFile(doc)
+ },
+ component: MediaPlayer,
+ })
+
+ type XHTMLMediaElement = HTMLMediaElement & { _setAudioPreload?: (isInView: boolean) => void }
+
+ let observer: IntersectionObserver | null = null
+
+ function setAudioPreload (this: XHTMLMediaElement, isInView: boolean) {
+ if (isInView && this._setAudioPreload) {
+ this.preload = 'metadata'
+ delete this._setAudioPreload
+ observer?.unobserve(this)
+ }
+ }
+
+ function cleanObserver () {
+ observer?.disconnect()
+ observer = null
+ }
+
+ ctx.registerHook('VIEW_RENDERED', () => {
+ cleanObserver()
+
+ const medias = ctx.view.getViewDom()?.querySelectorAll('audio')
+ if (medias && medias.length > 0) {
+ observer = new IntersectionObserver(entries => {
+ entries.forEach(entry => {
+ const el = entry.target as XHTMLMediaElement
+ el._setAudioPreload?.(entry.isIntersecting)
+ })
+ })
+
+ medias.forEach((media: XHTMLMediaElement) => {
+ if (media.preload === 'none') {
+ media._setAudioPreload = ctx.lib.lodash.debounce(setAudioPreload, 400, { leading: false, trailing: true })
+ observer!.observe(media)
+ }
+ })
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/misc.ts b/src/renderer/plugins/misc.ts
new file mode 100644
index 000000000..aab23eb25
--- /dev/null
+++ b/src/renderer/plugins/misc.ts
@@ -0,0 +1,22 @@
+import { Plugin } from '@fe/context'
+
+export default {
+ name: 'misc',
+ register: ctx => {
+ ctx.markdown.registerPlugin(md => {
+ md.renderer.rules.paragraph_open = (tokens, idx, options, env, self) => {
+ // auto recognize block image
+ if (
+ tokens[idx + 1]?.type === 'inline' &&
+ tokens[idx + 2]?.type === 'paragraph_close' &&
+ tokens[idx + 1]?.children?.length === 1 &&
+ (tokens[idx + 1]?.children?.[0]?.type === 'image' || tokens[idx + 1]?.children?.[0]?.type === 'media')
+ ) {
+ tokens[idx + 1]?.children?.[0].attrSet(ctx.args.DOM_ATTR_NAME.ONLY_CHILD, 'true')
+ }
+
+ return self.renderToken(tokens, idx, options)
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/preview-font.ts b/src/renderer/plugins/preview-font.ts
new file mode 100644
index 000000000..c816e5a34
--- /dev/null
+++ b/src/renderer/plugins/preview-font.ts
@@ -0,0 +1,68 @@
+import { h, ref } from 'vue'
+import type { Plugin } from '@fe/context'
+import type { Components } from '@fe/types'
+
+export default {
+ name: 'preview-font',
+ register: ctx => {
+ const defaultFontSize = 16
+ const storageFontSizeKey = 'plugin.preview-font.size'
+ const previewFontSize = ref(ctx.utils.storage.get(storageFontSizeKey, defaultFontSize))
+
+ function updateMarkdownBodyDom () {
+ const fontSize = previewFontSize.value
+ ctx.storage.set(storageFontSizeKey, fontSize)
+
+ ctx.view.getRenderIframe().then(iframe => {
+ const markdownBody = iframe.contentDocument?.querySelector(`.${ctx.args.DOM_CLASS_NAME.PREVIEW_MARKDOWN_BODY}`) as HTMLElement
+ if (markdownBody) {
+ markdownBody.style.fontSize = `${fontSize}px`
+ const fontFamily = ctx.setting.getSetting('view.default-previewer-font-family')
+ if (fontFamily) {
+ markdownBody.style.fontFamily = fontFamily
+ } else {
+ markdownBody.style.removeProperty('font-family')
+ }
+ }
+ })
+ }
+
+ function customFontSize (): Components.ControlCenter.Item {
+ ctx.lib.vue.watchEffect(updateMarkdownBodyDom)
+
+ return {
+ type: 'custom',
+ order: 1024,
+ hidden: !ctx.store.state.showView || ctx.store.state.previewer !== 'default',
+ component: () => h('div', { style: 'width: 100%; display: flex; justify-content: center; align-items: center; height: 40px; padding: 0 10px;' }, [
+ h('span', { style: 'margin-right: 8px; cursor: default', onClick: () => { previewFontSize.value = defaultFontSize } }, [
+ 'A',
+ h('span', { style: 'font-size: 12px;' }, 'A')
+ ]),
+ h('input', {
+ style: 'width: 100%;',
+ type: 'range',
+ min: 12,
+ max: 40,
+ step: 1,
+ value: previewFontSize.value,
+ onInput: (e: any) => {
+ previewFontSize.value = parseInt(e.target.value)
+ }
+ }),
+ h('output', { style: 'margin-left: 8px; font-size: 14px; font-variant-numeric: tabular-nums;' }, previewFontSize.value),
+ ])
+ }
+ }
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.switch.items.push(customFontSize())
+ })
+
+ ctx.registerHook('SETTING_CHANGED', ({ changedKeys }) => {
+ if (changedKeys.includes('view.default-previewer-font-family')) {
+ updateMarkdownBodyDom()
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/record-recent-document.ts b/src/renderer/plugins/record-recent-document.ts
new file mode 100644
index 000000000..f527cc808
--- /dev/null
+++ b/src/renderer/plugins/record-recent-document.ts
@@ -0,0 +1,27 @@
+import type { Plugin } from '@fe/context'
+
+export default {
+ name: 'record-recent-document',
+ register: (ctx) => {
+ // only support electron
+ if (!ctx.env.isElectron) {
+ return
+ }
+
+ // record recent document after markdown file saved
+ ctx.registerHook('DOC_SAVED', ({ doc }) => {
+ setTimeout(() => {
+ if (ctx.doc.isMarkdownFile(doc) && doc.absolutePath) {
+ let path = doc.absolutePath
+
+ // replace '/' to '\' on windows
+ if (ctx.env.isWindows) {
+ path = path.replaceAll('/', '\\')
+ }
+
+ ctx.env.getElectronRemote().app.addRecentDocument(path)
+ }
+ }, 0)
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/share-preview.tsx b/src/renderer/plugins/share-preview.tsx
new file mode 100644
index 000000000..6fb9d7d09
--- /dev/null
+++ b/src/renderer/plugins/share-preview.tsx
@@ -0,0 +1,153 @@
+import type { Plugin } from '@fe/context'
+import { FLAG_MAS } from '@fe/support/args'
+
+export default {
+ name: 'share-preview',
+ register: (ctx) => {
+ ctx.registerHook('STARTUP', () => {
+ if (ctx.args.MODE === 'share-preview') {
+ ctx.store.watch(() => ctx.store.state.presentation, val => {
+ if (!val) {
+ ctx.store.state.presentation = true
+ }
+ }, { immediate: true })
+ }
+ })
+
+ if (FLAG_MAS) {
+ return
+ }
+
+ const link = ctx.lib.vue.ref('')
+ const ip = ctx.lib.vue.ref('')
+
+ const panel = ctx.lib.vue.defineComponent({
+ setup () {
+ const expire = ctx.lib.vue.ref('2h')
+ const ips = ctx.lib.vue.ref([] as string[])
+
+ ctx.lib.vue.onMounted(async () => {
+ ips.value = await ctx.api.rpc(`
+ const ip = require('ip')
+ const os = require('os')
+ return Object.values(os.networkInterfaces())
+ .flat()
+ .map(x => x.address)
+ .filter(x => ip.isV4Format(x) && !ip.isLoopback(x))
+ `)
+ if (!ips.value.includes(ip.value)) {
+ ip.value = ips.value[0]
+ }
+ })
+
+ ctx.lib.vue.watch([expire, ip], async ([expire, ip]) => {
+ link.value = ''
+ const currentFile = ctx.store.state.currentFile
+ if (!currentFile) {
+ return
+ }
+
+ if (!expire || !ip) {
+ return
+ }
+
+ const token = await ctx.api.rpc(`return require('./jwt').getToken({ role: 'guest' }, '${expire}')`)
+ const port = location.port || ctx.args.$args().get('port') || '80'
+ const url = new URL(`http://${ip}:${port}`)
+ url.searchParams.set('mode', 'share-preview')
+ url.searchParams.set('token', token)
+ url.searchParams.set('init-repo', currentFile.repo)
+ url.searchParams.set('init-file', currentFile.path)
+ link.value = url.toString()
+ }, { immediate: true })
+
+ return () =>
+
-
+ {{ itemNode.name }} ({{itemNode.children ? itemNode.children.length : 0}})
-
-
+
+
diff --git a/src/renderer/index.ts b/src/renderer/index.ts
index 5aef15921..993c60332 100644
--- a/src/renderer/index.ts
+++ b/src/renderer/index.ts
@@ -1,22 +1,22 @@
-import './support/demo'
+import '@fe/others/demo'
import { createApp } from 'vue'
-import App from './App.vue'
-import router from './router'
+import Main from '@fe/Main.vue'
-import store from './support/store'
-import bus from './support/bus'
-import toast from './support/toast'
-import modal from './support/modal'
-import contextmenu from './support/context-menu'
+import directives from '@fe/directives'
+import toast from '@fe/support/ui/toast'
+import modal from '@fe/support/ui/modal'
+import contextmenu from '@fe/support/ui/context-menu'
+import quickFilter from '@fe/support/ui/quick-filter'
+import fixedFloat from '@fe/support/ui/fixed-float'
-const app = createApp(App)
+const app = createApp(Main)
-app.use(bus)
-app.use(store)
-app.use(router)
+app.use(directives)
app.use(toast)
app.use(modal)
app.use(contextmenu)
+app.use(quickFilter)
+app.use(fixedFloat)
app.mount('#app')
diff --git a/src/renderer/others/db.ts b/src/renderer/others/db.ts
new file mode 100644
index 000000000..ead1882ff
--- /dev/null
+++ b/src/renderer/others/db.ts
@@ -0,0 +1,81 @@
+import { difference } from 'lodash-es'
+import Dexie, { EntityTable } from 'dexie'
+import { getLogger } from '@fe/utils/pure'
+import type { IndexItem } from '@fe/types'
+
+const logger = getLogger('db')
+
+export interface DocumentEntity extends IndexItem {
+ id: number
+}
+
+const dbPrefix = 'yank-note-'
+
+const dbName = dbPrefix + __APP_VERSION__
+
+const db = new Dexie(dbName) as Dexie & {
+ documents: EntityTable
-
{{ item.name }}
+ @dblclick.prevent="onTreeNodeDblClick(item)"
+ @contextmenu.exact.prevent.stop="showContextMenu(itemNode)">
+
+ {{ itemNode.name }}
+
+ }
+ })
+
+ async function transformMarkdown () {
+ let markdown = ctx.store.state.currentContent
+ const tokens = ctx.view.getRenderEnv()?.tokens
+ if (!markdown || !tokens) {
+ return
+ }
+
+ const processImg = async (tokens: Token[]) => {
+ for (const token of tokens) {
+ if (token.children) {
+ await processImg(token.children)
+ }
+
+ if (token.tag === 'img' && token.attrGet(ctx.args.DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ const srcAttr = token.attrGet('src')
+ const originSrc = token.attrGet(ctx.args.DOM_ATTR_NAME.ORIGIN_SRC)
+ if (srcAttr && originSrc) {
+ const res: Response = await ctx.api.fetchHttp(srcAttr)
+ const fileName = ctx.utils.path.basename(ctx.utils.removeQuery(originSrc))
+ const file = new File(
+ [await res.blob()],
+ fileName,
+ { type: ctx.lib.mime.getType(fileName) || undefined }
+ )
+
+ let url: string | undefined
+ if (options.inlineLocalImage) {
+ url = await ctx.utils.fileToBase64URL(file)
+ } else if (options.uploadLocalImage) {
+ url = await ctx.action.getActionHandler('plugin.image-hosting-picgo.upload')(file)
+ }
+
+ if (url) {
+ markdown = markdown.replaceAll(
+ ctx.utils.encodeMarkdownLink(originSrc),
+ ctx.utils.encodeMarkdownLink(url)
+ )
+ }
+ }
+ }
+ }
+ }
+
+ await processImg(tokens)
+
+ return markdown
+ }
+
+ async function copyContent () {
+ const iframe = await ctx.view.getRenderIframe()
+ selectionLength.value = iframe.contentWindow?.getSelection()?.toString()?.trim()?.length || 0
+
+ if (await ctx.ui.useModal().confirm({
+ title: ctx.i18n.t('status-bar.tool.copy-content'),
+ component: panel,
+ })) {
+ try {
+ const startedAt = Date.now()
+ ctx.ui.useToast().show('info', ctx.i18n.t('loading'), 10000)
+ const content = options.type === 'markdown'
+ ? await transformMarkdown()
+ : await ctx.view.getContentHtml({ ...options, onlySelected: selectionLength.value > 0 })
+
+ if (Date.now() - startedAt > 3000) {
+ await ctx.ui.useModal().alert({ content: ctx.i18n.t('copy-content.complete') })
+ }
+
+ if (options.type === 'rt') {
+ await ctx.base.writeToClipboard('text/html', content)
+ ctx.ui.useToast().show('info', ctx.i18n.t('copied'))
+ } else {
+ ctx.utils.copyText(content)
+ }
+ } catch (error: any) {
+ console.error(error)
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ }
+
+ const id = 'plugin.copy-content.copy-content'
+
+ ctx.action.registerAction({
+ name: id,
+ description: ctx.i18n.t('command-desc.plugin_copy-content_copy-content'),
+ handler: copyContent,
+ forUser: true,
+ keys: [ctx.keybinding.CtrlCmd, ctx.keybinding.Shift, 'c'],
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-tool']?.list?.push(
+ {
+ id,
+ type: 'normal',
+ title: ctx.i18n.t('status-bar.tool.copy-content'),
+ subTitle: ctx.keybinding.getKeysLabel(id),
+ onClick: () => copyContent(),
+ ellipsis: true,
+ order: 100,
+ },
+ )
+ })
+
+ ctx.theme.addStyles(`
+ .copy-content {
+ margin-top: 20px;
+ }
+
+ .copy-content > div {
+ padding: 4px 12px;
+ display: flex;
+ }
+
+ .copy-content > div > div {
+ display: flex;
+ flex-wrap: wrap;
+ }
+
+ .copy-content .label {
+ width: 100px;
+ flex: none;
+ }
+
+ .copy-content label {
+ margin-left: 12px;
+ white-space: nowrap;
+ margin-bottom: 8px;
+ }
+
+ .copy-content .copy-content-tips {
+ font-size: 13px;
+ color: var(--g-color-35);
+ }
+ `)
+ }
+} as Plugin
diff --git a/src/renderer/plugins/copy-text.ts b/src/renderer/plugins/copy-text.ts
index dc5cb10c6..75996883e 100644
--- a/src/renderer/plugins/copy-text.ts
+++ b/src/renderer/plugins/copy-text.ts
@@ -1,15 +1,12 @@
-import { Plugin, Ctx } from '@fe/context/plugin'
-import { hasCtrlCmd } from '@fe/context/shortcut'
-import { encodeMarkdownLink } from '@fe/utils'
-import { copyText } from '@fe/support/copy-text'
+import { Plugin } from '@fe/context'
+import { hasCtrlCmd } from '@fe/core/keybinding'
+import { copyText, encodeMarkdownLink } from '@fe/utils'
import store from '@fe/support/store'
export default {
name: 'copy-text',
- register: (ctx: Ctx) => {
- ctx.action.registerAction('app.copy-text', copyText)
-
- ctx.registerHook('ON_VIEW_ELEMENT_CLICK', async (e: MouseEvent) => {
+ register: (ctx) => {
+ ctx.registerHook('VIEW_ELEMENT_CLICK', async ({ e }) => {
const target = e.target as HTMLElement
const preventEvent = () => {
@@ -18,16 +15,26 @@ export default {
return true
}
- // 复制标题链接
+ // copy heading link.
if (['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].indexOf(target.tagName) > -1 && target.id && hasCtrlCmd(e)) {
const { currentFile } = store.state
if (currentFile) {
- copyText(encodeMarkdownLink(currentFile.path) + '#' + encodeMarkdownLink(decodeURIComponent(target.id)))
+ let path = currentFile.path
+ if (!path.startsWith('/')) {
+ path = '/' + path
+ }
+
+ copyText(encodeMarkdownLink(path) + '#' + encodeMarkdownLink(decodeURIComponent(target.id)))
return preventEvent()
}
}
- // 复制内容
+ if (target.classList.contains('copy-text') && target.dataset.text) {
+ copyText(target.dataset.text)
+ return preventEvent()
+ }
+
+ // copy content.
if (target.classList.contains('copy-inner-text') && hasCtrlCmd(e)) {
copyText(target.innerText)
return preventEvent()
diff --git a/src/renderer/plugins/custom-keybindings.ts b/src/renderer/plugins/custom-keybindings.ts
new file mode 100644
index 000000000..d83e46be4
--- /dev/null
+++ b/src/renderer/plugins/custom-keybindings.ts
@@ -0,0 +1,279 @@
+/* eslint-disable quote-props */
+import type { Plugin } from '@fe/context'
+import type * as Monaco from 'monaco-editor'
+import { getLogger } from '@fe/utils'
+import { isMacOS } from '@fe/support/env'
+
+const logger = getLogger('plugin:custom-keybindings')
+
+let cachedMap: Record
+
+ {ctx.i18n.t('copy-content.type')}
+
+
+
+
+
+
+
+ {options.type !== 'markdown' && {ctx.i18n.t('copy-content.options')}
+
+
+
+ {options.type !== 'markdown' && }
+ {options.type !== 'markdown' && }
+
+
+ {
+ selectionLength.value
+ ? ctx.i18n.t('copy-content.copy-tips-selected', String(selectionLength.value))
+ : ctx.i18n.t('copy-content.copy-tips')
+ }
+
}
+
+
+
+
+
+
+
diff --git a/src/renderer/plugins/get-started/index.ts b/src/renderer/plugins/get-started/index.ts
new file mode 100644
index 000000000..b08cac65f
--- /dev/null
+++ b/src/renderer/plugins/get-started/index.ts
@@ -0,0 +1,17 @@
+import type { Plugin } from '@fe/context'
+import GetStarted from './GetStarted.vue'
+
+export default {
+ name: 'get-started',
+ register: (ctx) => {
+ ctx.editor.registerCustomEditor({
+ name: 'get-started',
+ displayName: 'Get Started',
+ hiddenPreview: true,
+ when ({ doc }) {
+ return doc === null && ctx.args.MODE === 'normal'
+ },
+ component: GetStarted,
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/history-stack.ts b/src/renderer/plugins/history-stack.ts
new file mode 100644
index 000000000..9f7eeb47c
--- /dev/null
+++ b/src/renderer/plugins/history-stack.ts
@@ -0,0 +1,202 @@
+import type { Plugin, Ctx } from '@fe/context'
+import type { Doc, PathItem, PositionState } from '@fe/types'
+
+type State = { doc: Doc, position?: PositionState | null}
+
+export default {
+ name: 'history-stack',
+ register: (ctx: Ctx) => {
+ const maxLength = 100
+ let stack: State[] = []
+ let idx = -1
+ const logger = ctx.utils.getLogger('plugin:history-stack')
+
+ const backId = 'plugin.document-history-stack.back'
+ const forwardId = 'plugin.document-history-stack.forward'
+
+ function refresh () {
+ ctx.workbench.ControlCenter.refresh()
+ ctx.statusBar.refreshMenu()
+
+ logger.debug('refresh', stack, idx, stack[idx])
+ }
+
+ function go (offset: number) {
+ const index = idx + offset
+ if (index >= stack.length || index < 0) {
+ return
+ }
+
+ const nextState = stack[index]
+
+ ctx.doc.switchDoc(nextState.doc, { source: 'history-stack', position: nextState.position }).then(() => {
+ idx = index
+ refresh()
+ })
+ }
+
+ function removeFromStack (doc?: PathItem) {
+ stack = stack.filter(x => !ctx.doc.isSubOrSameFile(doc, x.doc))
+ if (idx >= stack.length) {
+ idx = stack.length - 1
+ }
+
+ refresh()
+ }
+
+ function record (doc: Doc, position: PositionState | null) {
+ const newState: State = { doc: { type: doc.type, repo: doc.repo, name: doc.name, path: doc.path }, position }
+
+ // check same doc
+ if (stack[idx] && ctx.doc.isSameFile(doc, stack[idx].doc)) {
+ if (position) {
+ // check same position
+ if (ctx.lib.lodash.isEqual(position, stack[idx].position)) {
+ return
+ }
+ } else {
+ // not special position, check if already has position
+ if (isScrollPosition(stack[idx].position)) {
+ return
+ }
+ }
+ }
+
+ stack.splice(idx + 1, stack.length)
+ stack.push(newState)
+ idx = stack.length - 1
+
+ if (stack.length > maxLength) {
+ stack = stack.slice(stack.length - maxLength)
+ }
+
+ refresh()
+ }
+
+ function isScrollPosition (position: PositionState | undefined | null) {
+ return position && ('editorScrollTop' in position || 'viewScrollTop' in position)
+ }
+
+ function savePosition () {
+ const currentState = stack[idx]
+ const currentDoc = ctx.store.state.currentFile
+ if (!currentState || !currentDoc) {
+ return
+ }
+
+ // update scroll position when switching doc
+ if ((!currentState.position || isScrollPosition(currentState.position)) && ctx.doc.isSubOrSameFile(currentDoc, currentState.doc)) {
+ const viewScrollTop = ctx.view.getScrollTop() || 0
+ const editorScrollTop = ctx.editor.getEditor()?.getScrollTop() || 0
+ currentState.position = { viewScrollTop, editorScrollTop }
+ }
+ }
+
+ ctx.registerHook('DOC_PRE_SWITCH', () => {
+ savePosition()
+ })
+
+ ctx.registerHook('DOC_SWITCHED', ({ doc, opts }) => {
+ // do not record position when switching doc by history stack
+ if (opts?.source === 'history-stack') {
+ return
+ }
+
+ if (!doc && !opts?.position) {
+ return
+ }
+
+ const _doc = doc || ctx.store.state.currentFile
+ if (!_doc) {
+ return
+ }
+
+ const position = opts?.position || (stack as any).findLast((x: State) => {
+ return isScrollPosition(x.position) && ctx.doc.isSubOrSameFile(_doc, x.doc)
+ })?.position
+
+ if (!opts?.position && position) {
+ ctx.routines.changePosition(position)
+ }
+
+ record(_doc, null) // do not record cross doc position
+ })
+
+ ctx.registerHook('DOC_SWITCH_SKIPPED', ({ doc, opts }) => {
+ if (opts?.source === 'history-stack') {
+ return
+ }
+
+ // record in page navigation
+ if (doc && opts?.position) {
+ record(doc, opts?.position)
+ }
+ })
+
+ ctx.registerHook('DOC_DELETED', ({ doc }) => removeFromStack(doc))
+ ctx.registerHook('DOC_MOVED', ({ oldDoc }) => removeFromStack(oldDoc))
+ ctx.registerHook('DOC_SWITCH_FAILED', ({ doc }) => { doc && removeFromStack(doc) })
+
+ ctx.action.registerAction({
+ name: backId,
+ description: ctx.i18n.t('command-desc.plugin_document-history-stack_back'),
+ forUser: true,
+ handler: () => go(-1),
+ keys: [ctx.keybinding.Alt, ctx.keybinding.BracketLeft],
+ })
+
+ ctx.action.registerAction({
+ name: forwardId,
+ description: ctx.i18n.t('command-desc.plugin_document-history-stack_forward'),
+ forUser: true,
+ handler: () => go(1),
+ keys: [ctx.keybinding.Alt, ctx.keybinding.BracketRight],
+ })
+
+ ctx.registerHook('STARTUP', () => {
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-navigation']?.list?.push(
+ {
+ id: forwardId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('status-bar.nav.forward'),
+ disabled: idx >= stack.length - 1,
+ subTitle: ctx.keybinding.getKeysLabel(forwardId),
+ onClick: () => ctx.action.getActionHandler(forwardId)()
+ },
+ {
+ id: backId,
+ type: 'normal' as any,
+ title: ctx.i18n.t('status-bar.nav.back'),
+ disabled: idx <= 0,
+ subTitle: ctx.keybinding.getKeysLabel(backId),
+ onClick: () => ctx.action.getActionHandler(backId)()
+ },
+ )
+ })
+ })
+
+ ctx.workbench.ControlCenter.tapSchema(schema => {
+ schema.navigation.items.push(
+ {
+ type: 'btn',
+ icon: 'arrow-left-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.back', ctx.keybinding.getKeysLabel(backId)),
+ disabled: idx <= 0,
+ showInActionBar: true,
+ onClick: () => ctx.action.getActionHandler(backId)()
+ },
+ {
+ type: 'btn',
+ icon: 'arrow-right-solid',
+ flat: true,
+ title: ctx.i18n.t('control-center.navigation.forward', ctx.keybinding.getKeysLabel(forwardId)),
+ disabled: idx >= stack.length - 1,
+ showInActionBar: true,
+ onClick: () => ctx.action.getActionHandler(forwardId)()
+ },
+ )
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/image-hosting-picgo.ts b/src/renderer/plugins/image-hosting-picgo.ts
new file mode 100644
index 000000000..bd1a9d403
--- /dev/null
+++ b/src/renderer/plugins/image-hosting-picgo.ts
@@ -0,0 +1,278 @@
+import type Token from 'markdown-it/lib/token'
+import { Plugin, Ctx } from '@fe/context'
+import { DOM_ATTR_NAME, FLAG_DEMO } from '@fe/support/args'
+
+export default {
+ name: 'image-hosting-picgo',
+ register: (ctx: Ctx) => {
+ const logger = ctx.utils.getLogger('plugin.image-hosting-picgo')
+ const uploadActionName = 'plugin.image-hosting-picgo.upload'
+ const settingKeyUrl = 'plugin.image-hosting-picgo.server-url'
+ const settingKeyPaste = 'plugin.image-hosting-picgo.enable-paste-image'
+
+ ctx.setting.changeSchema((schema) => {
+ schema.properties[settingKeyUrl] = {
+ title: 'T_picgo.setting.api-title',
+ description: 'T_picgo.setting.api-desc',
+ type: 'string',
+ defaultValue: 'http://127.0.0.1:36677/upload',
+ pattern: '^(http://|https://|$)',
+ options: {
+ patternmessage: 'T_picgo.setting.api-msg',
+ },
+ group: 'image',
+ }
+
+ schema.properties[settingKeyPaste] = {
+ title: 'T_picgo.setting.paste-title',
+ type: 'boolean',
+ format: 'checkbox',
+ defaultValue: false,
+ group: 'image',
+ }
+ })
+
+ ctx.action.registerAction({
+ name: uploadActionName,
+ handler: async (file: File) => {
+ if (FLAG_DEMO) {
+ ctx.ui.useToast().show('warning', ctx.i18n.t('demo-tips'))
+ return URL.createObjectURL(file)
+ }
+
+ const url = ctx.setting.getSettings()[settingKeyUrl]
+
+ if (!url) {
+ const msg = ctx.i18n.t('picgo.need-api')
+ ctx.ui.useToast().show('warning', msg)
+ ctx.setting.showSettingPanel()
+ throw new Error(msg)
+ }
+
+ ctx.ui.useToast().show('info', ctx.i18n.t('picgo.uploading'), 0)
+
+ logger.debug('upload', url, file)
+
+ // remote mode, use multipart/form-data to upload
+ if (url.includes('key=')) {
+ const formData = new FormData()
+ formData.append('file', file)
+
+ try {
+ const { result } = await ctx.api.proxyFetch(
+ url,
+ { method: 'post', body: formData, },
+ ).then(r => r.json())
+
+ ctx.ui.useToast().hide()
+
+ if (result.length > 0) {
+ return result[0]
+ }
+ } catch (error) {
+ const msg = ctx.i18n.t('picgo.upload-failed')
+ ctx.ui.useToast().show('warning', msg)
+ throw new Error(msg)
+ }
+
+ return
+ }
+
+ const tmpFileName = 'picgo-' + file.name
+
+ try {
+ const { data: { path } } = await ctx.api.writeTmpFile(tmpFileName, await ctx.utils.fileToBase64URL(file), true)
+ logger.debug('tmp file', path)
+
+ const { result } = await ctx.api.proxyFetch(
+ url,
+ {
+ method: 'post',
+ body: { list: [path] },
+ jsonBody: true,
+ },
+ ).then(r => r.json())
+
+ ctx.ui.useToast().hide()
+
+ if (result.length > 0) {
+ return result[0]
+ }
+ } catch (error) {
+ const msg = ctx.i18n.t('picgo.upload-failed')
+ ctx.ui.useToast().show('warning', msg)
+ throw new Error(msg)
+ } finally {
+ ctx.api.deleteTmpFile(tmpFileName)
+ }
+ }
+ })
+
+ ctx.registerHook('EDITOR_PASTE_IMAGE', async ({ file }) => {
+ if (!ctx.setting.getSettings()[settingKeyPaste]) {
+ return false
+ }
+
+ await insertImage(file)
+
+ return true
+ })
+
+ async function insertImage (file: File) {
+ if (!ctx.store.state.currentFile) {
+ throw new Error('No file opened.')
+ }
+ const url = await ctx.action.getActionHandler(uploadActionName)(file)
+ ctx.editor.insert(`\n`)
+ }
+
+ function addImage () {
+ const input = window.document.createElement('input')
+ input.type = 'file'
+ input.multiple = true
+ input.onchange = async () => {
+ for (let i = 0; i < input.files!.length; i++) {
+ await insertImage(input.files![i])
+ }
+ }
+ input.click()
+ }
+
+ async function uploadLocalImage (srcAttr: string, originSrc: string) {
+ if (srcAttr && originSrc) {
+ const res: Response = await ctx.api.fetchHttp(srcAttr)
+ const fileName = ctx.utils.path.basename(ctx.utils.removeQuery(originSrc))
+ const file = new File(
+ [await res.blob()],
+ fileName,
+ { type: ctx.lib.mime.getType(fileName) || undefined }
+ )
+
+ try {
+ return await ctx.action.getActionHandler('plugin.image-hosting-picgo.upload')(file)
+ } catch (error) {
+ return null
+ }
+ }
+ }
+
+ async function uploadAllImage () {
+ const tokens = ctx.view.getRenderEnv()?.tokens
+ if (!tokens) {
+ return
+ }
+
+ const currentDocChecker = ctx.doc.createCurrentDocChecker()
+
+ const processImg = async (tokens: Token[]) => {
+ for (const token of tokens) {
+ currentDocChecker.throwErrorIfChanged()
+
+ if (token.children) {
+ await processImg(token.children)
+ }
+
+ if (token.tag === 'img' && token.attrGet(ctx.args.DOM_ATTR_NAME.LOCAL_IMAGE)) {
+ const srcAttr = token.attrGet('src')
+ const originSrc = token.attrGet(ctx.args.DOM_ATTR_NAME.ORIGIN_SRC)
+ const url = await uploadLocalImage(srcAttr!, originSrc!)
+
+ currentDocChecker.throwErrorIfChanged()
+
+ if (url) {
+ ctx.editor.replaceValue(
+ ctx.utils.encodeMarkdownLink(originSrc!),
+ ctx.utils.encodeMarkdownLink(url)
+ )
+ }
+ }
+ }
+ }
+
+ await processImg(tokens)
+ }
+
+ function when () {
+ const currentFile = ctx.store.state.currentFile
+ const previewFile = ctx.view.getRenderEnv()?.file
+
+ return !!(currentFile && ctx.editor.isDefault() && ctx.doc.isSameFile(currentFile, previewFile))
+ }
+
+ const addImageActionId = 'plugin.image-hosting-picgo.add-image'
+ const uploadAllImageActionId = 'plugin.image-hosting-picgo.upload-all-image'
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.addAction({
+ id: addImageActionId,
+ contextMenuGroupId: 'modification',
+ label: ctx.i18n.t('add-image') + ' (PicGo)',
+ run: addImage,
+ })
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ if (!when()) return
+
+ menus['status-bar-insert']?.list?.unshift({
+ id: addImageActionId,
+ type: 'normal',
+ title: ctx.i18n.t('add-image'),
+ ellipsis: true,
+ subTitle: 'PicGo',
+ onClick: addImage
+ })
+
+ menus['status-bar-tool']?.list?.push({
+ id: uploadAllImageActionId,
+ type: 'normal',
+ title: ctx.i18n.t('picgo.upload-all-images'),
+ subTitle: 'PicGo',
+ onClick: uploadAllImage
+ })
+ })
+
+ ctx.view.tapContextMenus((items, e) => {
+ if (!when()) return
+
+ const el = e.target as HTMLElement
+
+ if (
+ el.tagName === 'IMG' &&
+ el.getAttribute(DOM_ATTR_NAME.LOCAL_IMAGE)
+ ) {
+ const repo = el.getAttribute(DOM_ATTR_NAME.TARGET_REPO)
+ if (repo === ctx.args.HELP_REPO_NAME) {
+ return
+ }
+
+ items.push({
+ id: 'plugin.image-hosting-picgo.upload-single-image',
+ type: 'normal',
+ ellipsis: false,
+ label: ctx.i18n.t('upload-image') + ' (PicGo)',
+ onClick: async () => {
+ try {
+ if (!ctx.store.state.currentFile) {
+ throw new Error('No file opened.')
+ }
+
+ const srcAttr = el.getAttribute('src')
+ const originSrc = el.getAttribute(DOM_ATTR_NAME.ORIGIN_SRC)!
+
+ const url = await uploadLocalImage(srcAttr!, originSrc)
+ if (url) {
+ ctx.editor.replaceValue(
+ ctx.utils.encodeMarkdownLink(originSrc),
+ ctx.utils.encodeMarkdownLink(url)
+ )
+ }
+ } catch (error: any) {
+ ctx.ui.useToast().show('warning', error.message)
+ }
+ }
+ })
+ }
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/image-localization.ts b/src/renderer/plugins/image-localization.ts
new file mode 100644
index 000000000..efc324939
--- /dev/null
+++ b/src/renderer/plugins/image-localization.ts
@@ -0,0 +1,156 @@
+import mime from 'mime'
+import * as api from '@fe/support/api'
+import { encodeMarkdownLink, removeQuery } from '@fe/utils'
+import { useToast } from '@fe/support/ui/toast'
+import store from '@fe/support/store'
+import { replaceValue } from '@fe/services/editor'
+import { refreshTree } from '@fe/services/tree'
+import { upload } from '@fe/services/base'
+import { getViewDom } from '@fe/services/view'
+import type { Plugin } from '@fe/context'
+import type { BuildInActionName } from '@fe/types'
+
+async function transformImgOutLink (img: HTMLImageElement) {
+ const { currentFile } = store.state
+ if (!currentFile) {
+ return
+ }
+
+ const transform = (ximg: HTMLImageElement): Promise
+
+
+
+ {{$t('app-name')}}
+{{$t('slogan')}}
+
+
+
+
+ {{$t('get-started.start')}}
+ +
+
+ {{$t('get-started.help')}}
+ +
+
+ {{$t('get-started.recent')}}
+
+
+
+ {{item.node.name}}
+
+ {{dayjs(item.time).fromNow()}}
+
+
+
+ {{$t('more')}}…
+
+
+
+
+
+
+
+
diff --git a/src/renderer/plugins/insert-table/index.ts b/src/renderer/plugins/insert-table/index.ts
new file mode 100644
index 000000000..cc965b52b
--- /dev/null
+++ b/src/renderer/plugins/insert-table/index.ts
@@ -0,0 +1,152 @@
+import type { Plugin } from '@fe/context'
+import InsertTable from './InsertTable.vue'
+import { SimpleCompletionItem } from '@fe/services/editor'
+
+export default {
+ name: 'insert-table',
+ register: ctx => {
+ const actionName = 'plugin.insert-table'
+ const editorInsertCommand = 'vs.editor.ICodeEditor:1:' + actionName
+
+ function when () {
+ return !!(ctx.store.state.currentFile && ctx.doc.isMarkdownFile(ctx.store.state.currentFile))
+ }
+
+ function buildTableCompletionItems (): SimpleCompletionItem[] | false {
+ if (!when()) {
+ return []
+ }
+
+ const editor = ctx.editor.getEditor()
+ const position = editor.getPosition()
+ const prev2Lines = ((position && position.lineNumber > 2) ? ctx.editor.getLinesContent(position.lineNumber - 2, position.lineNumber - 1) : '').split('\n')
+ const tableCols = prev2Lines.reduce((acc: number, line: string) => {
+ const cols = line.split('|').length
+ return acc > 0 ? (acc === cols ? cols : -1) : cols
+ }, 0)
+
+ const currentLine = position ? ctx.editor.getLineContent(position.lineNumber) : ''
+
+ let i = 1
+ return /\|[^|]+/.test(currentLine) ? false : tableCols > 1
+ ? [
+ { language: 'markdown', label: '/ ||| Table Row', insertText: prev2Lines[0].replaceAll('\r', '').replace(/[^|]+/g, () => ` \${${i++}:--} `).trim() + '\n', block: true }
+ ]
+ : [
+ { language: 'markdown', label: '/ ||| Table', insertText: '', command: { id: editorInsertCommand, title: ctx.i18n.t('insert-table.insert-table') }, block: true },
+ ]
+ }
+
+ function canInsertTable () {
+ const tableItems = buildTableCompletionItems()
+ return Array.isArray(tableItems) && tableItems[0].command?.id === editorInsertCommand
+ }
+
+ ctx.editor.whenEditorReady().then(({ editor }) => {
+ editor.addAction({
+ id: actionName,
+ contextMenuGroupId: 'modification',
+ label: ctx.i18n.t('insert-table.insert-table'),
+ keybindings: [],
+ run: () => {
+ ctx.action.getActionHandler(actionName)()
+ },
+ })
+
+ ctx.editor.tapSimpleCompletionItems(items => {
+ const tableItems = buildTableCompletionItems()
+ if (tableItems === false) {
+ return
+ }
+
+ items.push(...tableItems)
+ })
+ })
+
+ function insertTable (params: { rows: number, cols: number, compact: boolean }) {
+ ctx.editor.getEditor().focus()
+
+ if (!canInsertTable()) {
+ return
+ }
+
+ let text = ''
+
+ const position = ctx.editor.getEditor().getPosition()
+ const lineNumber = position?.lineNumber
+ if (lineNumber && lineNumber > 2) {
+ const prevLineIsEmpty = !!(ctx.editor.getLineContent(lineNumber - 1))
+ if (prevLineIsEmpty) {
+ text += '\n'
+ }
+ }
+
+ // table head
+ for (let i = 0; i < params.cols; i++) {
+ text += `| TH_${i + 1} `
+ }
+ text += '|\n'
+
+ // table separator
+ for (let i = 0; i < params.cols; i++) {
+ text += '| -- '
+ }
+ text += '|\n'
+
+ // table body
+ for (let i = 0; i < params.rows; i++) {
+ for (let j = 0; j < params.cols; j++) {
+ text += `| TD_${i + 1}_${j + 1} `
+ }
+ text += '|\n'
+ }
+
+ if (params.compact) {
+ text += '{.small}\n'
+ }
+
+ ctx.editor.insert(text)
+ }
+
+ ctx.action.registerAction({
+ name: actionName,
+ forUser: true,
+ description: ctx.i18n.t('insert-table.insert-table'),
+ handler: () => {
+ if (canInsertTable()) {
+ const params = ctx.lib.vue.ref({ rows: 2, cols: 2, compact: false })
+
+ ctx.ui.useModal().confirm({
+ title: ctx.i18n.t('insert-table.insert-table'),
+ component: () => ctx.lib.vue.h(InsertTable, {
+ onConfirm: () => {
+ ctx.ui.useModal().ok()
+ },
+ onChange: (val: any) => { params.value = val }
+ }),
+ okText: ctx.i18n.t('insert-table.insert'),
+ }).then(val => {
+ if (val) {
+ insertTable(params.value)
+ }
+ })
+ } else {
+ ctx.ui.useToast().show('warning', 'Cannot insert table here')
+ }
+ },
+ when,
+ })
+
+ ctx.statusBar.tapMenus(menus => {
+ menus['status-bar-insert']?.list?.push({
+ id: actionName,
+ type: 'normal',
+ title: ctx.i18n.t('insert-table.insert-table'),
+ hidden: !when(),
+ onClick: () => {
+ ctx.action.getActionHandler(actionName)()
+ },
+ })
+ })
+ }
+} as Plugin
diff --git a/src/renderer/plugins/markdown-applet.ts b/src/renderer/plugins/markdown-applet.ts
index 328c8b7fd..93ce50ff6 100644
--- a/src/renderer/plugins/markdown-applet.ts
+++ b/src/renderer/plugins/markdown-applet.ts
@@ -1,55 +1,97 @@
-import { h } from 'vue'
-import CryptoJS from 'crypto-js'
-import dayjs from 'dayjs'
+import { defineComponent, h, onBeforeUnmount, ref } from 'vue'
import Markdown from 'markdown-it'
-import { Plugin } from '@fe/context/plugin'
-import { IFrame } from '@fe/context/embed'
+import { registerHook, removeHook } from '@fe/core/hook'
+import { IFrame } from '@fe/support/embed'
+import { md5 } from '@fe/utils'
+import type { Plugin } from '@fe/context'
+import type { RenderEnv } from '@fe/types'
+
+const Applet = defineComponent({
+ name: 'XApplet',
+ props: {
+ appletId: String,
+ html: String,
+ attrs: Object as () => Record
+
+
+
+
+
+
+
+
+
+ x
+
+
+ ${lines[i].length > 0 ? lines[i] : ' '}
` +
+ '{6}
' +
- '' + katex.renderToString(latex, options) + '
' - } catch (error) { - if (options.throwOnError) { console.error(error) } + const { innerHTML, cacheKey } = renderToString(latex, options) + return h('p', { ...token.meta?.attrs, key: idx + cacheKey, innerHTML }, '') + } catch (error: any) { return h('code', {}, `${error.message} [${latex}]`) } } - const blockRenderer = function (tokens: any, idx: any) { - return katexBlock(tokens[idx].content) + '\n' - } - md.inline.ruler.after('escape', 'math_inline', math_inline) md.block.ruler.after('blockquote', 'math_block', math_block, { alt: ['paragraph', 'reference', 'blockquote', 'list'] @@ -204,11 +232,43 @@ function math_plugin (md: any, options: any) { export default { name: 'markdown-katex', register: ctx => { - ctx.theme.addStyles(` + ctx.view.addStyles(` + ${styles} + .markdown-view .markdown-body .katex { background: initial; } `) + ctx.markdown.registerPlugin(math_plugin, { throwOnError: true }) + + ctx.editor.whenEditorReady().then(({ monaco }) => { + monacoLatex(monaco) + }) + + ctx.editor.tapSimpleCompletionItems(items => { + /* eslint-disable no-template-curly-in-string */ + + items.push( + { language: 'latex', label: '/ \\begin KaTeX Environment', insertText: '\\begin{$1}\n$2\n\\end{$1}', block: true }, + { language: 'markdown', label: '/ $ Inline KaTeX', insertText: '$$1$' }, + { language: 'markdown', label: '/ $$ Block KaTeX', insertText: '$$$1$$\n', block: true }, + ) + }) + + ctx.editor.tapMarkdownMonarchLanguage(mdLanguage => { + mdLanguage.tokenizer.root.unshift( + [/\$\$/, { token: 'tag', next: '@latexBlockEnd', nextEmbedded: 'latex' }], + [/\$(?=\S)/, { token: 'tag', next: '@latexInlineEnd', nextEmbedded: 'latex' }], + ) + + mdLanguage.tokenizer.latexBlockEnd = [ + [/\$\$/, { token: 'tag', next: '@pop', nextEmbedded: '@pop' }], + ] + + mdLanguage.tokenizer.latexInlineEnd = [ + [/\$/, { token: 'tag', next: '@pop', nextEmbedded: '@pop' }], + ] + }) } } as Plugin diff --git a/src/renderer/plugins/markdown-link.ts b/src/renderer/plugins/markdown-link.ts deleted file mode 100644 index d0e155ad8..000000000 --- a/src/renderer/plugins/markdown-link.ts +++ /dev/null @@ -1,174 +0,0 @@ -import StateCore from 'markdown-it/lib/rules_core/state_core' -import Token from 'markdown-it/lib/token' -import { Plugin, Ctx } from '@fe/context/plugin' -import store from '@fe/support/store' -import env from '@fe/utils/env' -import { basename, dirname, join } from '@fe/utils/path' -import { switchDoc } from '@fe/context/document' - -const handleLink = (link: HTMLAnchorElement) => { - const { currentFile } = store.state - if (!currentFile) { - return - } - - const { repo: fileRepo, path: filePath } = currentFile - - // 系统中打开附件 - if (link.classList.contains('open')) { - fetch(link.href.replace('api/attachment', 'api/open')) - return true - } - - const href = link.getAttribute('href') || '' - - if (/^(http:|https:|ftp:)\/\//i.test(href)) { // 处理外链 - // Electron 中打开外链 - if (env.isElectron) { - env.require && env.require('opn')(link.href) - return true - } - } else { // 处理相对链接 - if (/(\.md$|\.md#)/.test(href)) { // 处理打开相对 md 文件 - const tmp = decodeURI(href).split('#') - - let path = tmp[0] - if (!path.startsWith('/')) { // 将相对路径转换为绝对路径 - path = join(dirname(filePath || ''), path) - } - - // 打开文件 - switchDoc({ - path, - name: basename(path), - repo: fileRepo, - type: 'file' - }) - - // 跳转锚点 - const hash = tmp.slice(1).join('#') - if (hash) { - setTimeout(() => { - const el = document.getElementById(hash) || - document.getElementById(encodeURIComponent(hash)) - - if (el) { - // 如果是标题的话，也顺便将编辑器滚动到可视区域 - if (hash.startsWith('h-')) { - el.click() - } - el.scrollIntoView() - } - }, 50) - } - - return true - } else if (href && href.startsWith('#')) { // 处理 TOC 跳转 - const el = document.getElementById(href.replace(/^#/, '')) - if (el) { - el.scrollIntoView() - } - return true - } - - return false - } -} - -function convertLink (state: StateCore) { - const tags = ['audio', 'img', 'source', 'video', 'track', 'a'] - - const { repo, path, name } = state.env.file || {} - if (!repo || !path || !name) { - return false - } - - const link = (token: Token) => { - const attrName = token.tag === 'a' ? 'href' : 'src' - const attrVal = decodeURIComponent(token.attrGet(attrName) || '') - if (!attrVal) { - return - } - - if (/^[^:]*:/.test(attrVal)) { // xxx: : 开头不转换 - return - } - - const basePath = dirname(path) - const fileName = basename(attrVal) - - if (token.tag === 'a') { - // md 文件不替换 - if (fileName.endsWith('.md')) { - return - } - - // 路径中有 hash 不替换 - if (attrVal.indexOf('#') > -1) { - return - } - } - - token.attrSet(`origin-${attrName}`, attrVal) - - if (repo === '__help__') { - token.attrSet(attrName, `api/help/file?path=${encodeURIComponent(attrVal)}`) - return - } - - const filePath = join(basePath, attrVal) - token.attrSet(attrName, `api/attachment/${encodeURIComponent(fileName)}?repo=${repo}&path=${encodeURIComponent(filePath)}`) - } - - const convert = (tokens: Token[]) => { - tokens.forEach(token => { - if (tags.includes(token.tag)) { - link(token) - } - - if (token.children) { - convert(token.children) - } - }) - } - - convert(state.tokens) - - return true -} - -export default { - name: 'markdown-link', - register: (ctx: Ctx) => { - ctx.registerHook('ON_VIEW_ELEMENT_CLICK', async (e: MouseEvent) => { - const target = e.target as HTMLElement - - const preventEvent = () => { - e.preventDefault() - e.stopPropagation() - return true - } - - if (target.tagName === 'A' || target.parentElement?.tagName === 'A') { - if (handleLink(target as HTMLAnchorElement)) { - return preventEvent() - } else { - return true - } - } - - return false - }) - - ctx.markdown.registerPlugin(md => { - md.core.ruler.push('convert_relative_path', convertLink) - md.renderer.rules.link_open = (tokens, idx, options, _, slf) => { - if (tokens[idx].attrIndex('target') < 0) { - tokens[idx].attrPush(['target', '_blank']) - } - - return slf.renderToken(tokens, idx, options) - } - }) - } -} as Plugin diff --git a/src/renderer/plugins/markdown-link/index.ts b/src/renderer/plugins/markdown-link/index.ts new file mode 100644 index 000000000..9a9465567 --- /dev/null +++ b/src/renderer/plugins/markdown-link/index.ts @@ -0,0 +1,298 @@ +import StateCore from 'markdown-it/lib/rules_core/state_core' +import ctx, { Plugin } from '@fe/context' +import store from '@fe/support/store' +import { removeQuery } from '@fe/utils' +import { isElectron, isWindows } from '@fe/support/env' +import { useToast } from '@fe/support/ui/toast' +import { DOM_ATTR_NAME, DOM_CLASS_NAME } from '@fe/support/args' +import { basename, join } from '@fe/utils/path' +import { getAttachmentURL, openExternal, openPath } from '@fe/services/base' +import { getRepo } from '@fe/services/repo' +import { getAvailableCustomEditors } from '@fe/services/editor' +import { fetchTree } from '@fe/support/api' +import { isMarkdownFile } from '@share/misc' +import { getRenderEnv } from '@fe/services/view' +import { convertResourceState, parseLink } from './lib' +import workerIndexerUrl from './worker-indexer?worker&url' +import type { Doc, ParseLinkResult } from '@fe/types' + +function getAnchorElement (target: HTMLElement) { + let cur: HTMLElement | null = target + while (cur && cur.tagName !== 'A' && cur.tagName !== 'ARTICLE') { + cur = cur.parentElement + } + + return cur?.tagName === 'A' ?