= ({ id, children }) => {
14 | const { attributes, listeners, setNodeRef, transform, transition } =
15 | useSortable({ id })
16 |
17 | const style: React.CSSProperties = {
18 | transform: CSS.Transform.toString(transform),
19 | transition,
20 | }
21 |
22 | return (
23 |
24 | {children(attributes, listeners)}
25 |
26 | )
27 | }
28 |
--------------------------------------------------------------------------------
/src/components/TagManagement.tsx:
--------------------------------------------------------------------------------
1 | import { Button, Group, Input, Paper, Space, Title } from '@mantine/core'
2 | import { useCallback } from 'react'
3 | import { Controller, useForm } from 'react-hook-form'
4 |
5 | import { updateBlocks } from '../services/core/update-blocks'
6 | import { updateSettings } from '../services/core/update-settings'
7 | import { handleDynamicVariables } from '../services/handle-dynamic-variables'
8 | import {
9 | PropertiesProps,
10 | TagProperties,
11 | TagPropertiesProps,
12 | } from './TagProperties'
13 |
14 | interface FormData {
15 | [key: string]: {
16 | newProp: string
17 | defaultValue: string
18 | }
19 | }
20 |
21 | export const TagManagement = ({
22 | index,
23 | setLocalTags,
24 | properties,
25 | tags,
26 | }: TagPropertiesProps) => {
27 | const { control, handleSubmit, reset } = useForm()
28 |
29 | const deletePowertag = useCallback(
30 | async (index: string) => {
31 | updateSettings((currSavedTags) => {
32 | const { [index]: _, ...rest } = currSavedTags
33 | return rest
34 | })
35 | await updateBlocks(index, async (block) => {
36 | const props = await logseq.Editor.getBlockProperties(block.uuid)
37 | await Promise.all(
38 | Object.keys(props).map((propKey) =>
39 | logseq.Editor.removeBlockProperty(block.uuid, propKey),
40 | ),
41 | )
42 | await logseq.UI.showMsg(
43 | `PowerTag ${index} deleted. Properties removed from ${block.uuid}`,
44 | 'success',
45 | )
46 | })
47 | },
48 | [tags],
49 | )
50 |
51 | const addNewProp = useCallback(
52 | async (data: FormData) => {
53 | const index = Object.keys(data)[0]
54 | if (!index || !data[index]) return
55 | const tag = data[index]
56 |
57 | updateSettings((currSavedTags) => {
58 | const properties = currSavedTags[index]
59 | if (!properties) return
60 | if (
61 | properties.some(
62 | (property: PropertiesProps) => property.name === tag.newProp,
63 | )
64 | ) {
65 | logseq.UI.showMsg(`${tag.newProp} already exists`, 'error')
66 | return currSavedTags
67 | }
68 | return {
69 | ...currSavedTags,
70 | [index]: [
71 | ...properties,
72 | { name: tag.newProp, value: tag.defaultValue },
73 | ],
74 | }
75 | })
76 |
77 | reset()
78 |
79 | await updateBlocks(index, async (block) => {
80 | const propValue = await handleDynamicVariables(tag.defaultValue)
81 | await logseq.Editor.upsertBlockProperty(
82 | block.uuid,
83 | tag.newProp,
84 | propValue,
85 | )
86 | await logseq.UI.showMsg(
87 | `New property added to ${index}. ${block.uuid} updated with new property`,
88 | 'success',
89 | )
90 | })
91 | },
92 | [tags],
93 | )
94 |
95 | return (
96 |
97 |
98 | #{index}
99 |
102 |
103 |
104 |
110 |
111 |
134 |
135 | )
136 | }
137 |
--------------------------------------------------------------------------------
/src/components/TagProperties.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | DndContext,
3 | DragEndEvent,
4 | PointerSensor,
5 | useSensor,
6 | useSensors,
7 | } from '@dnd-kit/core'
8 | import {
9 | arrayMove,
10 | SortableContext,
11 | verticalListSortingStrategy,
12 | } from '@dnd-kit/sortable'
13 | import { ActionIcon, Flex, Stack, Text } from '@mantine/core'
14 | import { ArrowDownUp, Trash } from 'lucide-react'
15 | import { Dispatch, SetStateAction, useCallback } from 'react'
16 |
17 | import { Tag } from '../features'
18 | import { updateBlocks } from '../services/core/update-blocks'
19 | import { updateSettings } from '../services/core/update-settings'
20 | import { reorderBlockProperties } from '../services/re-ordering'
21 | import { SortableItem } from './SortableItem'
22 |
23 | export interface PropertiesProps {
24 | name: string
25 | value: string
26 | }
27 |
28 | export interface TagPropertiesProps {
29 | setLocalTags: Dispatch>
30 | index: string
31 | properties: PropertiesProps[]
32 | tags: Tag
33 | }
34 |
35 | export const TagProperties = ({
36 | setLocalTags,
37 | index,
38 | properties,
39 | tags,
40 | }: TagPropertiesProps) => {
41 | const sensors = useSensors(
42 | useSensor(PointerSensor, {
43 | activationConstraint: {
44 | distance: 8,
45 | },
46 | }),
47 | )
48 |
49 | const handleDragEnd = useCallback(
50 | async (event: DragEndEvent) => {
51 | let localProps
52 | const { active, over } = event
53 |
54 | if (active.id !== over?.id) {
55 | setLocalTags((prevTags) => {
56 | if (!prevTags) return prevTags
57 |
58 | const newTags = { ...prevTags }
59 | const tagIndex = Object.keys(prevTags).find((key) =>
60 | prevTags[key]!.some((prop) => prop.name === active.id),
61 | )
62 |
63 | if (!tagIndex) return prevTags
64 |
65 | const activeIndex = prevTags[tagIndex]!.findIndex(
66 | (prop) => prop.name === active.id,
67 | )
68 | const overIndex = prevTags[tagIndex]!.findIndex(
69 | (prop) => prop.name === over?.id,
70 | )
71 | if (activeIndex === -1 || overIndex === -1) return prevTags
72 | newTags[tagIndex] = arrayMove(
73 | prevTags[tagIndex]!,
74 | activeIndex,
75 | overIndex,
76 | )
77 |
78 | // Save to settings
79 | updateSettings((currSavedTags) => ({
80 | ...currSavedTags,
81 | [index]: newTags[tagIndex],
82 | }))
83 | localProps = newTags[tagIndex]
84 |
85 | return newTags
86 | })
87 | reorderBlockProperties(index, localProps!)
88 | }
89 | },
90 | [tags],
91 | )
92 |
93 | const deleteProperty = useCallback(
94 | async (index: string, name: string) => {
95 | updateSettings((currSavedTags) => ({
96 | ...currSavedTags,
97 | [index]: currSavedTags[index]?.filter(
98 | (property: { name: string }) => property.name !== name,
99 | ),
100 | }))
101 |
102 | await updateBlocks(index, async (block) => {
103 | await logseq.Editor.removeBlockProperty(block.uuid, name)
104 | await logseq.UI.showMsg(
105 | `Property ${name} deleted from #${index}. Block ${block.uuid} updated`,
106 | 'success',
107 | )
108 | })
109 | },
110 | [tags],
111 | )
112 |
113 | return (
114 |
115 | prop.name)}
117 | strategy={verticalListSortingStrategy}
118 | >
119 |
120 | {properties.map(({ name, value }) => (
121 |
122 | {(attributes, listeners) => (
123 |
129 |
136 |
137 |
138 | {name}:: {value}
139 |
140 |
141 | {properties.length > 1 && (
142 | deleteProperty(index, name)}
144 | variant="outline"
145 | color="red"
146 | >
147 |
148 |
149 | )}
150 |
151 | )}
152 |
153 | ))}
154 |
155 |
156 |
157 | )
158 | }
159 |
--------------------------------------------------------------------------------
/src/constants.ts:
--------------------------------------------------------------------------------
1 | import { createTheme } from '@mantine/core'
2 |
3 | export const THEME = createTheme({
4 | primaryColor: 'darkTeal',
5 | primaryShade: 9,
6 | colors: {
7 | darkTeal: [
8 | '#ecfbfd',
9 | '#daf4f8',
10 | '#b0e8f2',
11 | '#85dded',
12 | '#66d3e9',
13 | '#56cde6',
14 | '#4ccae6',
15 | '#3eb2cd',
16 | '#2f9eb7',
17 | '#0d89a0',
18 | ],
19 | },
20 | })
21 |
--------------------------------------------------------------------------------
/src/features/create-tag/index.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | ActionIcon,
3 | Button,
4 | Flex,
5 | Group,
6 | Input,
7 | Space,
8 | Title,
9 | } from '@mantine/core'
10 | import { useCallback } from 'react'
11 | import { Controller, useFieldArray, useForm } from 'react-hook-form'
12 |
13 | interface PowerTag {
14 | tagName: string
15 | properties: {
16 | name: string
17 | value: string
18 | }[]
19 | }
20 |
21 | export const CreateTag = () => {
22 | const { control, handleSubmit, watch, reset } = useForm({
23 | defaultValues: {
24 | tagName: '',
25 | properties: [{ name: '', value: '' }],
26 | },
27 | })
28 |
29 | const { fields, append, remove } = useFieldArray({
30 | control,
31 | name: 'properties',
32 | rules: {
33 | minLength: 1,
34 | },
35 | })
36 |
37 | const onSubmit = useCallback(async (data: PowerTag) => {
38 | // Check if tag already exists
39 | const currSavedTags = logseq.settings!.savedTags
40 | if (currSavedTags[data.tagName]) {
41 | await logseq.UI.showMsg(`#${data.tagName} already exists`, 'error')
42 | return
43 | }
44 |
45 | logseq.updateSettings({
46 | savedTags: {
47 | [data.tagName.toLowerCase()]: data.properties,
48 | },
49 | })
50 | reset()
51 | logseq.hideMainUI()
52 | await logseq.UI.showMsg('PowerTag saved!', 'success')
53 | }, [])
54 |
55 | return (
56 |
57 | Create
58 |
59 |
60 |
123 |
124 |
125 | )
126 | }
127 |
--------------------------------------------------------------------------------
/src/features/index.css:
--------------------------------------------------------------------------------
1 | body {
2 | background: none !important;
3 | }
4 |
--------------------------------------------------------------------------------
/src/features/index.tsx:
--------------------------------------------------------------------------------
1 | import './index.css'
2 | import '@mantine/core/styles.css'
3 |
4 | import {
5 | CloseButton,
6 | Flex,
7 | Group,
8 | MantineProvider,
9 | Space,
10 | Title,
11 | } from '@mantine/core'
12 | import { useEffect, useState } from 'react'
13 |
14 | import { THEME } from '../constants'
15 | import { CreateTag } from './create-tag'
16 | import { ManageTags } from './manage-tags'
17 |
18 | export interface Tag {
19 | [key: string]: { name: string; value: string }[]
20 | }
21 |
22 | const PowerTags = () => {
23 | const [tags, setTags] = useState({})
24 |
25 | useEffect(() => {
26 | setTags(logseq.settings!.savedTags)
27 | })
28 |
29 | const closeModal = () => {
30 | logseq.hideMainUI()
31 | }
32 |
33 | return (
34 |
35 |
36 |
45 |
46 | PowerTags Menu
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 | )
56 | }
57 |
58 | export default PowerTags
59 |
--------------------------------------------------------------------------------
/src/features/manage-tags/index.tsx:
--------------------------------------------------------------------------------
1 | import { Flex, Space, Text, Title } from '@mantine/core'
2 | import { useEffect, useState } from 'react'
3 |
4 | import { TagManagement } from '../../components/TagManagement'
5 | import { Tag } from '..'
6 |
7 | export const ManageTags = ({ tags }: { tags: Tag }) => {
8 | const [localTags, setLocalTags] = useState({})
9 |
10 | useEffect(() => {
11 | setLocalTags(tags)
12 | }, [tags])
13 |
14 | if (!localTags) return Error in plugin settings...
15 |
16 | return (
17 |
18 | Manage
19 |
20 | Deleting a PowerTag or property will affect all blocks that reference
21 | this PowerTag, even if they were not created with this plugin.
22 |
23 |
24 |
25 | {Object.entries(localTags).map(([index, properties]) => (
26 |
33 | ))}
34 |
35 |
36 | )
37 | }
38 |
--------------------------------------------------------------------------------
/src/global.d.ts:
--------------------------------------------------------------------------------
1 | declare module '*.css?raw' {
2 | const content: string
3 | export default content
4 | }
5 |
--------------------------------------------------------------------------------
/src/handle-popup.ts:
--------------------------------------------------------------------------------
1 | export const handlePopup = () => {
2 | // Hit 'Esc' to close pop-up
3 | document.addEventListener(
4 | 'keydown',
5 | (e: KeyboardEvent) => {
6 | if (e.key === 'Escape') {
7 | logseq.hideMainUI({ restoreEditingCursor: true })
8 | }
9 | e.stopPropagation()
10 | },
11 | false,
12 | )
13 | }
14 |
--------------------------------------------------------------------------------
/src/index.tsx:
--------------------------------------------------------------------------------
1 | import '@logseq/libs'
2 |
3 | import { createRoot } from 'react-dom/client'
4 |
5 | import PowerTags from './features'
6 | import { handlePopup } from './handle-popup'
7 | import { observerCallback } from './observerCallback'
8 | import { handlePowerTag } from './services/handle-power-tag'
9 | import settings from './settings'
10 |
11 | const main = () => {
12 | console.log('logseq-powertags-plugin loaded')
13 | handlePopup()
14 |
15 | // Create a savedTags object in settings if it doesn't exist
16 | if (!logseq.settings!.savedTags) {
17 | logseq.updateSettings({ savedTags: {} })
18 | }
19 |
20 | const el = document.getElementById('app')
21 | if (!el) return
22 | const root = createRoot(el)
23 |
24 | logseq.provideModel({
25 | async managePowerTags() {
26 | root.render()
27 | logseq.showMainUI()
28 | },
29 | })
30 | logseq.App.registerUIItem('toolbar', {
31 | key: 'logseq-powertags-plugin',
32 | template: ``,
33 | })
34 |
35 | if (logseq.settings!.autoParse) {
36 | //@ts-expect-error need to access Logseq parent
37 | const observer = new parent.MutationObserver(observerCallback)
38 | observer.observe(parent.document.getElementById('app-container'), {
39 | attributes: false,
40 | childList: true,
41 | subtree: true,
42 | })
43 | }
44 |
45 | logseq.Editor.registerSlashCommand('Parse PowerTag', async (e) => {
46 | await handlePowerTag(e.uuid)
47 | })
48 | }
49 |
50 | logseq.useSettingsSchema(settings).ready(main).catch(console.error)
51 |
--------------------------------------------------------------------------------
/src/observerCallback.ts:
--------------------------------------------------------------------------------
1 | import { handlePowerTag } from './services/handle-power-tag'
2 |
3 | export const observerCallback = async (mutationsList: any[]) => {
4 | for (const mutation of mutationsList) {
5 | if (
6 | mutation.type === 'childList' &&
7 | mutation.removedNodes.length > 0 &&
8 | mutation.removedNodes[0].className === 'editor-inner block-editor'
9 | ) {
10 | const uuid = mutation.target
11 | .closest('div[id^="ls-block"]')
12 | ?.getAttribute('blockid')
13 |
14 | await handlePowerTag(uuid)
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/services/core/query-blocks-with-tag.ts:
--------------------------------------------------------------------------------
1 | import { BlockEntity } from '@logseq/libs/dist/LSPlugin'
2 |
3 | export const queryBlocksWithTag = async (
4 | tag: string,
5 | ): Promise => {
6 | let blocks = await logseq.DB.q(`[[${tag}]]`)
7 | if (!blocks || blocks.length === 0) {
8 | await logseq.UI.showMsg(`No blocks with PowerTag: ${tag} found`)
9 | logseq.hideMainUI()
10 | return null
11 | }
12 | // Only retrieve blocks where its parent is the page so that child blocks are not selected and properties are being added to child blocks
13 | blocks = blocks.filter(
14 | (block: BlockEntity) => block.page.id === block.parent.id,
15 | )
16 | return blocks
17 | }
18 |
--------------------------------------------------------------------------------
/src/services/core/update-blocks.ts:
--------------------------------------------------------------------------------
1 | import { BlockEntity } from '@logseq/libs/dist/LSPlugin'
2 |
3 | import { queryBlocksWithTag } from './query-blocks-with-tag'
4 |
5 | export const updateBlocks = async (
6 | tag: string,
7 | operation: (block: BlockEntity) => Promise,
8 | ) => {
9 | const blocks = await queryBlocksWithTag(tag)
10 | if (!blocks) return
11 |
12 | await Promise.all(blocks.map(operation))
13 | logseq.hideMainUI()
14 | }
15 |
--------------------------------------------------------------------------------
/src/services/core/update-settings.ts:
--------------------------------------------------------------------------------
1 | import { PropertiesProps } from '../../components/TagProperties'
2 |
3 | export const updateSettings = (
4 | updateFn: (currSettings: { [key: string]: PropertiesProps[] }) => void,
5 | ) => {
6 | const currSavedTags = logseq.settings!.savedTags
7 | const updatedSettings = updateFn(currSavedTags)
8 |
9 | logseq.updateSettings({
10 | savedTags: 'Need to add some arbitrary string first',
11 | })
12 | logseq.updateSettings({ savedTags: updatedSettings })
13 | }
14 |
--------------------------------------------------------------------------------
/src/services/handle-dynamic-variables.ts:
--------------------------------------------------------------------------------
1 | import { format, startOfTomorrow, startOfYesterday } from 'date-fns'
2 | import { getDateForPage } from 'logseq-dateutils'
3 |
4 | type DynamicVariable =
5 | | 'today'
6 | | 'yesterday'
7 | | 'tomorrow'
8 | | 'time'
9 | | 'current page'
10 |
11 | const getPreferredDateFormat = async (): Promise => {
12 | return (await logseq.App.getUserConfigs()).preferredDateFormat
13 | }
14 |
15 | const dynamicVariableHandlers: Record Promise> =
16 | {
17 | today: async () =>
18 | getDateForPage(new Date(), await getPreferredDateFormat()),
19 | yesterday: async () =>
20 | getDateForPage(startOfYesterday(), await getPreferredDateFormat()),
21 | tomorrow: async () =>
22 | getDateForPage(startOfTomorrow(), await getPreferredDateFormat()),
23 | time: async () => format(new Date(), 'HH:mm'),
24 | 'current page': async () => {
25 | const currBlock = await logseq.Editor.getCurrentBlock()
26 | if (!currBlock) return ''
27 | const currPage = await logseq.Editor.getPage(currBlock.page.id)
28 | if (!currPage) return ''
29 | return `[[${currPage.name}]]`
30 | },
31 | }
32 |
33 | export const handleDynamicVariables = async (
34 | propValue: string,
35 | ): Promise => {
36 | const match = propValue.match(/<%\s*(.*?)\s*%>/)
37 | if (!match || !match[1]) return propValue
38 |
39 | const dVar = match[1] as DynamicVariable
40 | const handler = dynamicVariableHandlers[dVar]
41 | return handler ? await handler() : propValue
42 | }
43 |
--------------------------------------------------------------------------------
/src/services/handle-power-tag.ts:
--------------------------------------------------------------------------------
1 | import { handleDynamicVariables } from './handle-dynamic-variables'
2 |
3 | export const handlePowerTag = async (uuid: string) => {
4 | const blk = await logseq.Editor.getBlock(uuid)
5 | if (!blk) return
6 | const tagMatch = /#(?:\[\[(.*?)\]\]|(\w+))/.exec(blk.content)
7 | if (!tagMatch) return
8 |
9 | // Check whether tag is a PowerTag
10 | const tag = tagMatch[1] ?? tagMatch[2]
11 | if (!tag) return
12 |
13 | const powerTag = logseq.settings!.savedTags[tag.toLowerCase()]
14 | if (!powerTag) return
15 |
16 | //****RULES OF ENGAGEMENT****//
17 | // Ignore if properties already exist
18 | // Handle partial properties
19 | // Handle no properties exist
20 | //**************************//
21 |
22 | for (const property of powerTag) {
23 | const currProperty = await logseq.Editor.getBlockProperty(
24 | uuid,
25 | property.name,
26 | )
27 | if (currProperty) continue
28 |
29 | // Handle dynamic variables
30 | const propValue = await handleDynamicVariables(property.value)
31 |
32 | await logseq.Editor.upsertBlockProperty(uuid, property.name, propValue)
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/services/re-ordering/index.ts:
--------------------------------------------------------------------------------
1 | import { BlockEntity } from '@logseq/libs/dist/LSPlugin'
2 |
3 | import { PropertiesProps } from '../../components/TagProperties'
4 | import { updateBlocks } from '../core/update-blocks'
5 | import { insertOrderedProps } from './insert-ordered-properties'
6 | import { removeAllProperties } from './remove-all-properties'
7 | import { reorderProperties } from './reorder-properties'
8 |
9 | export const reorderBlockProperties = async (
10 | index: string,
11 | localProps: PropertiesProps[],
12 | ) => {
13 | const newOrder = localProps.map((prop) => prop.name)
14 |
15 | await updateBlocks(index, async (block: BlockEntity) => {
16 | const blockProps = await logseq.Editor.getBlockProperties(block.uuid)
17 | const newOrderBlockProps = reorderProperties(blockProps, newOrder)
18 | if (!newOrderBlockProps) return
19 |
20 | await removeAllProperties(block.uuid, Object.keys(blockProps))
21 | await insertOrderedProps(block.uuid, newOrderBlockProps)
22 |
23 | await logseq.UI.showMsg(
24 | `Properties rearranged for ${block.uuid}`,
25 | 'success',
26 | )
27 | })
28 |
29 | logseq.hideMainUI()
30 | }
31 |
--------------------------------------------------------------------------------
/src/services/re-ordering/insert-ordered-properties.ts:
--------------------------------------------------------------------------------
1 | import { GenericProperty } from './reorder-properties'
2 |
3 | export const insertOrderedProps = async (
4 | uuid: string,
5 | properties: GenericProperty,
6 | ) => {
7 | await Promise.all(
8 | Object.entries(properties).map(([key, value]) =>
9 | logseq.Editor.upsertBlockProperty(uuid, key, value),
10 | ),
11 | )
12 | }
13 |
--------------------------------------------------------------------------------
/src/services/re-ordering/remove-all-properties.ts:
--------------------------------------------------------------------------------
1 | export const removeAllProperties = async (uuid: string, propKeys: string[]) => {
2 | await Promise.all(
3 | propKeys.map((propKey) => logseq.Editor.removeBlockProperty(uuid, propKey)),
4 | )
5 | }
6 |
--------------------------------------------------------------------------------
/src/services/re-ordering/reorder-properties.ts:
--------------------------------------------------------------------------------
1 | export interface GenericProperty {
2 | [key: string]: any
3 | }
4 |
5 | export const reorderProperties = (
6 | properties: { [key: string]: any },
7 | order: string[],
8 | ) => {
9 | const newProperties: GenericProperty = {}
10 | order.forEach((key) => {
11 | if (Object.prototype.hasOwnProperty.call(properties, key)) {
12 | newProperties[key] = properties[key]
13 | }
14 | })
15 | return newProperties
16 | }
17 |
--------------------------------------------------------------------------------
/src/settings.ts:
--------------------------------------------------------------------------------
1 | import { SettingSchemaDesc } from '@logseq/libs/dist/LSPlugin.user'
2 |
3 | const settings: SettingSchemaDesc[] = [
4 | {
5 | key: 'autoParse',
6 | type: 'boolean',
7 | default: true,
8 | title: 'Auto Parse',
9 | description: `If set to true, blocks containing a #powertag will automatically have its properties added.`,
10 | },
11 | ]
12 |
13 | export default settings
14 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "jsx": "react-jsx",
4 | "target": "es2017",
5 | "lib": [
6 | "dom",
7 | "dom.iterable",
8 | "esnext"
9 | ],
10 | "allowJs": true,
11 | "checkJs": true,
12 | "skipLibCheck": true,
13 | "strict": true,
14 | "forceConsistentCasingInFileNames": true,
15 | "noEmit": true,
16 | "esModuleInterop": true,
17 | "module": "esnext",
18 | "moduleResolution": "node",
19 | "resolveJsonModule": true,
20 | "isolatedModules": true,
21 | "incremental": true,
22 | "noUncheckedIndexedAccess": true,
23 | "baseUrl": "./",
24 | "paths": {
25 | "../*": [
26 | "src/*"
27 | ]
28 | }
29 | },
30 | "include": [
31 | "**/*.ts",
32 | "**/*.tsx",
33 | "**/*.cjs",
34 | "**/*.mjs"
35 | ],
36 | "exclude": [
37 | "node_modules",
38 | "./dist/**/*",
39 | "./screenshots",
40 | "tailwind.config.js"
41 | ]
42 | }
43 |
--------------------------------------------------------------------------------
/vite.config.ts:
--------------------------------------------------------------------------------
1 | import { defineConfig } from 'vite'
2 | import logseqDevPlugin from 'vite-plugin-logseq'
3 |
4 | export default defineConfig({
5 | plugins: [logseqDevPlugin()],
6 | })
7 |
--------------------------------------------------------------------------------