@antelopejs/dms-mailing 0.5.0 → 0.5.1

package/frontend-vue/app/composables/useSortableList.ts

@@ -0,0 +1,159 @@
+import { useSortable } from '@vueuse/integrations/useSortable'
+import { toValue, watch, type MaybeRefOrGetter, type Ref } from 'vue'
+
+/** What a drop did to a list, as vuedraggable's `change` event said it. */
+export interface SortableListChange<Item> {
+	added?: { element: Item; newIndex: number }
+	removed?: { element: Item; oldIndex: number }
+	moved?: { element: Item; oldIndex: number; newIndex: number }
+}
+
+export interface SortableGroup {
+	name: string
+	/** `'clone'`: the list keeps its items and hands a copy to the other list. */
+	pull?: boolean | 'clone'
+	/** `false`: no item of another list lands here. */
+	put?: boolean
+}
+
+export interface SortableListOptions<Item> {
+	/** Lists sharing a group name exchange items. */
+	group?: string | SortableGroup
+	/** Read again whenever it changes. */
+	disabled?: MaybeRefOrGetter<boolean>
+	/** Only an item grabbed by an element matching this selector moves. */
+	handle?: string
+	/**
+	 * The children that are items, when the list element holds others (a
+	 * footer): the indexes SortableJS reports count these only.
+	 */
+	draggable?: string
+	/** `false`: the items cannot be reordered within the list. */
+	sort?: boolean
+	/** Class of the slot the dragged item will land in. */
+	ghostClass?: string
+	/** What another list receives in place of the dragged item. */
+	clone?: (item: Item) => unknown
+	onChange?: (change: SortableListChange<Item>) => void
+	/** After every drag, whatever it changed. */
+	onEnd?: () => void
+}
+
+/** What the list reads of SortableJS's events. */
+interface SortableEvent {
+	item: HTMLElement
+	clone: HTMLElement
+	oldIndex?: number
+	newIndex?: number
+	pullMode?: boolean | 'clone'
+}
+
+/**
+ * The options the list sets. SortableJS keeps its default only for an option
+ * absent from the object: a key set to `undefined` replaces it (an undefined
+ * `draggable` makes no child an item, so nothing drags).
+ */
+function defined<Options extends object>(options: Options): Partial<Options> {
+	return Object.fromEntries(
+		Object.entries(options).filter(([, value]) => value !== undefined),
+	) as Partial<Options>
+}
+
+/**
+ * The item being dragged, by group. A drop on another list only names the
+ * element, which belongs to the list it left: the list it lands in reads the
+ * item the other one stored when the drag started.
+ */
+const dragged = new Map<string, unknown>()
+
+/**
+ * Lets the user reorder the items of `list` rendered in `root`, or move them
+ * to another list of the same group: SortableJS, through VueUse's
+ * `useSortable`.
+ *
+ * SortableJS moves the dragged element in the DOM itself. Vue owns these
+ * elements, so each drop puts the element back where Vue rendered it and
+ * changes `list` in place instead, from which Vue renders the new order.
+ */
+export function useSortableList<Item>(
+	root: Ref<HTMLElement | null>,
+	list: () => Item[],
+	options: SortableListOptions<Item> = {},
+): void {
+	const groupName =
+		typeof options.group === 'string'
+			? options.group
+			: (options.group?.name ?? '')
+
+	/**
+	 * Where the dragged element stood: next to the node that followed it, not
+	 * at an index, as Vue removes an item by the markers around it.
+	 */
+	let origin: { parent: Node; next: Node | null } | undefined
+
+	function restore(item: HTMLElement): void {
+		if (origin) origin.parent.insertBefore(item, origin.next)
+	}
+
+	const { option } = useSortable(root, list, {
+		...defined({
+			group: options.group,
+			handle: options.handle,
+			draggable: options.draggable,
+			ghostClass: options.ghostClass,
+		}),
+		disabled: toValue(options.disabled) ?? false,
+		sort: options.sort ?? true,
+		onStart: (event: SortableEvent) => {
+			const { parentNode, nextSibling } = event.item
+			origin = parentNode
+				? { parent: parentNode, next: nextSibling }
+				: undefined
+			const element = list()[event.oldIndex ?? -1]
+			if (element === undefined) return
+			dragged.set(groupName, options.clone ? options.clone(element) : element)
+		},
+		onUpdate: (event: SortableEvent) => {
+			const { oldIndex, newIndex } = event
+			if (oldIndex === undefined || newIndex === undefined) return
+			restore(event.item)
+			const items = list()
+			const [element] = items.splice(oldIndex, 1)
+			if (element === undefined) return
+			items.splice(newIndex, 0, element)
+			options.onChange?.({ moved: { element, oldIndex, newIndex } })
+		},
+		onAdd: (event: SortableEvent) => {
+			const element = dragged.get(groupName) as Item | undefined
+			const { newIndex } = event
+			if (element === undefined || newIndex === undefined) return
+			// The element goes back to the list it left, below.
+			event.item.remove()
+			list().splice(newIndex, 0, element)
+			options.onChange?.({ added: { element, newIndex } })
+		},
+		onRemove: (event: SortableEvent) => {
+			restore(event.item)
+			// A copy left: the list keeps its item, and SortableJS's stand-in goes.
+			if (event.pullMode === 'clone') {
+				event.clone.remove()
+				return
+			}
+			const { oldIndex } = event
+			if (oldIndex === undefined) return
+			const [element] = list().splice(oldIndex, 1)
+			if (element === undefined) return
+			options.onChange?.({ removed: { element, oldIndex } })
+		},
+		onEnd: () => {
+			origin = undefined
+			dragged.delete(groupName)
+			options.onEnd?.()
+		},
+	})
+
+	watch(
+		() => toValue(options.disabled) ?? false,
+		(disabled) => option('disabled', disabled),
+	)
+}

package/frontend-vue/app/utils/blocks/dnd.ts

@@ -9,6 +9,8 @@ export const PALETTE_GROUP = {
 	put: false,
 }
 export const DRAG_HANDLE = '.mailing-drag-handle'
+/** The blocks of a list, not the insert point that ends it. */
+export const DRAG_ITEM = '>[data-drag-item]'
 
 /** The block a tile dropped on the canvas becomes, shaped by its template. */
 export function cloneFromPalette(

package/frontend-vue/i18n/locales/mailing-en-GB.json

@@ -804,7 +804,7 @@
 				},
 				"webhookUrl": {
 					"label": "Webhook URL",
-					"description": "Your provider, or the relay that translates its events, posts them here with the secret below. The module README describes the format."
+					"description": "Your provider, or the relay that translates its events, posts them here with the secret below. The module documentation describes the format."
 				},
 				"webhookStatus": {
 					"label": "Webhook status",

package/frontend-vue/i18n/locales/mailing-fr-FR.json

@@ -804,7 +804,7 @@
 				},
 				"webhookUrl": {
 					"label": "URL du webhook",
-					"description": "Votre fournisseur, ou le relais qui traduit ses événements, les envoie ici avec le secret ci-dessous. Le README du module décrit le format."
+					"description": "Votre fournisseur, ou le relais qui traduit ses événements, les envoie ici avec le secret ci-dessous. La documentation du module décrit le format."
 				},
 				"webhookStatus": {
 					"label": "État du webhook",

package/frontend-vue/package.json

@@ -6,7 +6,7 @@
 	"license": "Apache-2.0",
 	"packageManager": "pnpm@10.2.0",
 	"engines": {
-		"@antelopejs/dms-frontend": ">=0.6.0 <0.7.0"
+		"@antelopejs/dms-frontend": ">=0.6.3 <0.7.0"
 	},
 	"scripts": {
 		"format": "prettier --write .",
@@ -16,8 +16,9 @@
 	},
 	"dependencies": {
 		"@vueuse/core": "^14.3.0",
-		"vue": "^3.5.18",
-		"vuedraggable": "^4.1.0"
+		"@vueuse/integrations": "^14.3.0",
+		"sortablejs": "^1.14.0",
+		"vue": "^3.5.18"
 	},
 	"devDependencies": {
 		"@nuxt/ui": "4.10.0",

package/frontend-vue/pnpm-lock.yaml

@@ -11,12 +11,15 @@ importers:
       '@vueuse/core':
         specifier: ^14.3.0
         version: 14.4.0(vue@3.5.42(typescript@5.9.3))
+      '@vueuse/integrations':
+        specifier: ^14.3.0
+        version: 14.4.0(fuse.js@7.5.0)(sortablejs@1.14.0)(vue@3.5.42(typescript@5.9.3))
+      sortablejs:
+        specifier: ^1.14.0
+        version: 1.14.0
       vue:
         specifier: ^3.5.18
         version: 3.5.42(typescript@5.9.3)
-      vuedraggable:
-        specifier: ^4.1.0
-        version: 4.1.0(vue@3.5.42(typescript@5.9.3))
     devDependencies:
       '@nuxt/ui':
         specifier: 4.10.0
@@ -3154,11 +3157,6 @@ packages:
       typescript:
         optional: true
 
-  vuedraggable@4.1.0:
-    resolution: {integrity: sha512-FU5HCWBmsf20GpP3eudURW3WdWTKIbEIQxh9/8GE806hydR9qZqRRxRE3RjqX7PkuLuMQG/A7n3cfj9rCEchww==}
-    peerDependencies:
-      vue: ^3.0.1
-
   w3c-keyname@2.2.8:
     resolution: {integrity: sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==}
 
@@ -6245,11 +6243,6 @@ snapshots:
     optionalDependencies:
       typescript: 5.9.3
 
-  vuedraggable@4.1.0(vue@3.5.42(typescript@5.9.3)):
-    dependencies:
-      sortablejs: 1.14.0
-      vue: 3.5.42(typescript@5.9.3)
-
   w3c-keyname@2.2.8: {}
 
   w3c-xmlserializer@5.0.0:

package/frontend-vue/tests/editor-block-list.test.ts

@@ -12,6 +12,24 @@ import EditorBlockList from '../app/components/editor/EditorBlockList.vue'
 import type { Block } from '../app/types/mailing'
 
 const editor = vi.hoisted(() => ({ touch: vi.fn(), select: vi.fn() }))
+const sortables = vi.hoisted(
+	() => [] as { el: HTMLElement; options: Record<string, unknown> }[],
+)
+
+// What SortableJS would be handed: the test calls it as SortableJS does.
+vi.mock('@vueuse/integrations/useSortable', async () => {
+	const { onMounted, unref } = await import('vue')
+	return {
+		useSortable: (
+			target: { value: HTMLElement },
+			_list: unknown,
+			options: Record<string, unknown>,
+		) => {
+			onMounted(() => sortables.push({ el: unref(target), options }))
+			return { option: () => {} }
+		},
+	}
+})
 
 vi.mock('../app/composables/useEditorContext', () => ({
 	useEditorContext: () => ({ editor }),
@@ -60,14 +78,36 @@ describe('editor draggable items', () => {
 	})
 	it('selects a block dropped into the list', async () => {
 		vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
-		const list = reactive<Block[]>([])
-		const app = createApp(EditorBlockList, { list })
+		sortables.length = 0
+		const source = reactive<Block[]>([
+			{ id: 'dropped', type: 'divider', visibleIf: null },
+		])
+		const target = reactive<Block[]>([])
+		const app = createApp({
+			render: () => [
+				h(EditorBlockList, { list: source }),
+				h(EditorBlockList, { list: target }),
+			],
+		})
 		app.mount(document.createElement('div'))
 		try {
-			const draggable = app._instance?.subTree.props as Record<string, unknown>
-			const onChange = draggable.onChange as (change: unknown) => void
-			onChange({ added: { element: { id: 'dropped' }, newIndex: 0 } })
-			onChange({ moved: { element: { id: 'other' } } })
+			const [from, to] = sortables
+			expect(from!.options).toMatchObject({
+				group: { name: 'mailing-blocks' },
+				handle: '.mailing-drag-handle',
+				draggable: '>[data-drag-item]',
+			})
+			const item = from!.el.querySelector('[data-drag-item]') as HTMLElement
+			const handler = (sortable: typeof from, name: string) =>
+				sortable!.options[name] as (event: unknown) => void
+			handler(from, 'onStart')({ item, oldIndex: 0 })
+			to!.el.prepend(item)
+			handler(to, 'onAdd')({ item, newIndex: 0 })
+			handler(from, 'onRemove')({ item, oldIndex: 0 })
+			handler(from, 'onEnd')({})
+			await nextTick()
+			expect(source).toEqual([])
+			expect(target.map((block) => block.id)).toEqual(['dropped'])
 			expect(editor.touch).toHaveBeenCalledTimes(2)
 			expect(editor.select).toHaveBeenCalledExactlyOnceWith('dropped')
 		} finally {

package/frontend-vue/tests/sortable-list.test.ts

@@ -0,0 +1,253 @@
+// @vitest-environment jsdom
+/**
+ * The drag and drop of the categories, the canvas blocks and the palette:
+ * SortableJS moves the dragged element in the DOM, the list puts it back and
+ * changes its array, and Vue renders the new order. The drags are replayed as
+ * SortableJS reports them, DOM moves included.
+ */
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import {
+	createApp,
+	defineComponent,
+	h,
+	nextTick,
+	reactive,
+	ref,
+	type App,
+} from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+type Options = Record<string, unknown>
+
+interface FakeSortable {
+	el: HTMLElement
+	options: Options
+}
+
+const instances: FakeSortable[] = []
+
+// SortableJS needs a pointer to drag with: what the test drives is the
+// options the list hands it, called as SortableJS calls them.
+vi.mock('@vueuse/integrations/useSortable', async () => {
+	const { onMounted, unref } = await import('vue')
+	return {
+		useSortable: (
+			target: { value: HTMLElement },
+			_list: unknown,
+			options: Options,
+		) => {
+			const sortable = { el: undefined as unknown as HTMLElement, options }
+			onMounted(() => {
+				sortable.el = unref(target)
+				instances.push(sortable)
+			})
+			return {
+				option: (name: string, value: unknown) => {
+					sortable.options[name] = value
+				},
+			}
+		},
+	}
+})
+
+const { useSortableList } = await import('../app/composables/useSortableList')
+
+interface Item {
+	id: string
+}
+
+let app: App | undefined
+
+afterEach(() => {
+	app?.unmount()
+	app = undefined
+	instances.length = 0
+})
+
+const List = defineComponent({
+	props: {
+		items: { type: Array as () => Item[], required: true },
+		options: { type: Object, default: () => ({}) },
+	},
+	setup(props) {
+		const root = ref<HTMLElement | null>(null)
+		useSortableList(root, () => props.items, props.options)
+		return () =>
+			h(
+				'div',
+				{ ref: root },
+				props.items.map((item) =>
+					h('p', { key: item.id, 'data-id': item.id }, item.id),
+				),
+			)
+	},
+})
+
+function mountLists(lists: { items: Item[]; options: Options }[]) {
+	const host = document.createElement('div')
+	document.body.append(host)
+	app = createApp({
+		render: () => lists.map((list) => h(List, list)),
+	})
+	app.mount(host)
+	return host
+}
+
+const ids = (items: Item[]) => items.map((item) => item.id)
+const domIds = (sortable: FakeSortable) =>
+	[...sortable.el.children].map((child) => child.getAttribute('data-id'))
+const call = (sortable: FakeSortable, name: string, event: unknown) =>
+	(sortable.options[name] as (event: unknown) => void)(event)
+
+describe('useSortableList', () => {
+	it('reorders a list in place and renders the new order', async () => {
+		const items = reactive([{ id: 'a' }, { id: 'b' }, { id: 'c' }])
+		const changes: unknown[] = []
+		const ended = vi.fn()
+		mountLists([
+			{
+				items,
+				options: { onChange: (c: unknown) => changes.push(c), onEnd: ended },
+			},
+		])
+		const [list] = instances
+		const item = list!.el.children[0] as HTMLElement
+		call(list!, 'onStart', { item, oldIndex: 0 })
+		// SortableJS has moved the element already when it reports the update.
+		list!.el.append(item)
+		call(list!, 'onUpdate', { item, oldIndex: 0, newIndex: 2 })
+		call(list!, 'onEnd', {})
+		await nextTick()
+		expect(ids(items)).toEqual(['b', 'c', 'a'])
+		expect(domIds(list!)).toEqual(['b', 'c', 'a'])
+		expect(changes).toEqual([
+			{ moved: { element: { id: 'a' }, oldIndex: 0, newIndex: 2 } },
+		])
+		expect(ended).toHaveBeenCalledOnce()
+	})
+
+	it('moves an item to another list of its group', async () => {
+		const source = reactive([{ id: 'a' }, { id: 'b' }])
+		const target = reactive([{ id: 'x' }])
+		const sourceChanges: unknown[] = []
+		const targetChanges: unknown[] = []
+		mountLists([
+			{
+				items: source,
+				options: {
+					group: 'g',
+					onChange: (c: unknown) => sourceChanges.push(c),
+				},
+			},
+			{
+				items: target,
+				options: {
+					group: 'g',
+					onChange: (c: unknown) => targetChanges.push(c),
+				},
+			},
+		])
+		const [from, to] = instances
+		const item = from!.el.children[1] as HTMLElement
+		call(from!, 'onStart', { item, oldIndex: 1 })
+		to!.el.prepend(item)
+		// SortableJS reports the add on the target first, then the remove.
+		call(to!, 'onAdd', { item, newIndex: 0 })
+		call(from!, 'onRemove', { item, oldIndex: 1 })
+		call(from!, 'onEnd', {})
+		await nextTick()
+		expect(ids(source)).toEqual(['a'])
+		expect(ids(target)).toEqual(['b', 'x'])
+		expect(domIds(from!)).toEqual(['a'])
+		expect(domIds(to!)).toEqual(['b', 'x'])
+		expect(sourceChanges).toEqual([
+			{ removed: { element: { id: 'b' }, oldIndex: 1 } },
+		])
+		expect(targetChanges).toEqual([
+			{ added: { element: { id: 'b' }, newIndex: 0 } },
+		])
+	})
+
+	it('hands a copy to the other list and keeps its own item (pull: clone)', async () => {
+		const palette = reactive([{ id: 'tile' }])
+		const canvas = reactive<Item[]>([])
+		const group = { name: 'g', pull: 'clone', put: false }
+		mountLists([
+			{
+				items: palette,
+				options: {
+					group,
+					sort: false,
+					clone: (item: Item) => ({ id: `${item.id}-copy` }),
+				},
+			},
+			{ items: canvas, options: { group: { name: 'g' } } },
+		])
+		const [from, to] = instances
+		expect(from!.options.group).toBe(group)
+		expect(from!.options.sort).toBe(false)
+		const item = from!.el.children[0] as HTMLElement
+		call(from!, 'onStart', { item, oldIndex: 0 })
+		// SortableJS leaves a stand-in where the tile was and drags the tile.
+		const stand = item.cloneNode(true) as HTMLElement
+		from!.el.insertBefore(stand, item)
+		to!.el.append(item)
+		call(to!, 'onAdd', { item, newIndex: 0 })
+		call(from!, 'onRemove', {
+			item,
+			clone: stand,
+			oldIndex: 0,
+			pullMode: 'clone',
+		})
+		call(from!, 'onEnd', {})
+		await nextTick()
+		expect(ids(palette)).toEqual(['tile'])
+		expect(ids(canvas)).toEqual(['tile-copy'])
+		expect(domIds(from!)).toEqual(['tile'])
+		expect(domIds(to!)).toEqual(['tile-copy'])
+	})
+
+	it('passes the handle, the item selector and a disabled state it follows', async () => {
+		const disabled = ref(false)
+		mountLists([
+			{
+				items: reactive([{ id: 'a' }]),
+				options: {
+					handle: '[data-drag-handle]',
+					draggable: '>[data-drag-item]',
+					ghostClass: 'opacity-30',
+					disabled: () => disabled.value,
+				},
+			},
+		])
+		const [list] = instances
+		expect(list!.options).toMatchObject({
+			handle: '[data-drag-handle]',
+			draggable: '>[data-drag-item]',
+			ghostClass: 'opacity-30',
+			disabled: false,
+			sort: true,
+		})
+		disabled.value = true
+		await nextTick()
+		expect(list!.options.disabled).toBe(true)
+	})
+
+	it('leaves SortableJS its defaults for what the list does not set', () => {
+		mountLists([{ items: reactive([{ id: 'a' }]), options: {} }])
+		const [list] = instances
+		// A key present with `undefined` would replace the default: an
+		// undefined `draggable` makes no child an item, and nothing drags.
+		for (const name of ['group', 'handle', 'draggable', 'ghostClass'])
+			expect(list!.options).not.toHaveProperty(name)
+	})
+
+	it('no longer ships vuedraggable, which bundled the Vue compiler', () => {
+		const manifest = JSON.parse(
+			readFileSync(resolve(__dirname, '../package.json'), 'utf8'),
+		) as { dependencies: Record<string, string> }
+		expect(manifest.dependencies).not.toHaveProperty('vuedraggable')
+		expect(manifest.dependencies).toHaveProperty('sortablejs')
+	})
+})

package/package.json

@@ -1,6 +1,19 @@
 {
   "name": "@antelopejs/dms-mailing",
-  "version": "0.5.0",
+  "version": "0.5.1",
+  "description": "E-mail templates for the AntelopeJS DMS: a block editor with drafts and versions, a send log, delivery metrics and a suppression list.",
+  "keywords": [
+    "antelopejs",
+    "dms",
+    "dms-module",
+    "email",
+    "mailing",
+    "templates"
+  ],
+  "homepage": "https://dms.antelopejs.com/docs/modules/mailing",
+  "bugs": {
+    "url": "https://github.com/AntelopeJS/dms-mailing/issues"
+  },
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -14,6 +27,7 @@
     "!dist/.tsbuildinfo",
     "!dist/test",
     "frontend-vue",
+    "skills",
     "src",
     "!src/test"
   ],
@@ -32,21 +46,21 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@antelopejs/interface-api": ">=0.0.13 <1.0.0",
-    "@antelopejs/interface-api-util": ">=0.1.2 <1.0.0",
-    "@antelopejs/interface-core": ">=0.1.1 <1.0.0",
-    "@antelopejs/interface-data-api": ">=0.2.1 <1.0.0",
-    "@antelopejs/interface-database": ">=0.1.9 <1.0.0",
-    "@antelopejs/interface-database-decorators": ">=0.1.7 <1.0.0",
-    "@antelopejs/interface-dms": ">=0.7.0 <1.0.0",
-    "@antelopejs/interface-dms-mailing": ">=0.7.0 <0.8.0",
-    "@antelopejs/interface-email": ">=0.0.5 <1.0.0",
+    "@antelopejs/interface-api": ">=0.0.15 <1.0.0",
+    "@antelopejs/interface-api-util": ">=0.1.3 <1.0.0",
+    "@antelopejs/interface-core": ">=0.2.4 <1.0.0",
+    "@antelopejs/interface-data-api": ">=0.2.2 <1.0.0",
+    "@antelopejs/interface-database": ">=0.1.10 <1.0.0",
+    "@antelopejs/interface-database-decorators": ">=0.1.9 <1.0.0",
+    "@antelopejs/interface-dms": ">=0.7.2 <1.0.0",
+    "@antelopejs/interface-dms-mailing": ">=0.7.1 <0.8.0",
+    "@antelopejs/interface-email": ">=0.0.6 <1.0.0",
     "node-cron": "^4.2.1",
     "zod": "~3.24.2"
   },
   "devDependencies": {
-    "@antelopejs/core": ">=1.13.4 <2",
-    "@antelopejs/tooling-configs": ">=0.0.7 <1.0.0",
+    "@antelopejs/core": ">=1.16.0 <2",
+    "@antelopejs/tooling-configs": ">=0.0.9 <1.0.0",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10",
     "@types/node": "^24.0.0",
@@ -64,14 +78,17 @@
     "typescript": "^6.0.3"
   },
   "optionalDependencies": {
-    "@antelopejs/interface-dms-automation": ">=0.1.0 <1.0.0"
+    "@antelopejs/interface-dms-automation": ">=0.2.1 <1.0.0"
   },
   "antelopeJs": {
     "baseUrl": "dist",
     "implements": [
       "@antelopejs/interface-dms-mailing"
     ],
-    "test": "src/test/antelope.test.ts"
+    "test": "src/test/antelope.test.ts",
+    "skills": [
+      "./skills"
+    ]
   },
   "scripts": {
     "build": "rimraf dist && tsc",