@prosekit/core 0.8.2 → 0.8.4

package/src/extensions/text.ts

@@ -0,0 +1,34 @@
+import type { Attrs } from '@prosekit/pm/model'
+
+import type { Extension } from '../types/extension'
+
+import { defineNodeSpec } from './node-spec'
+
+/**
+ * @internal
+ */
+export type TextExtension = Extension<{
+  Nodes: {
+    text: Attrs
+  }
+}>
+
+/**
+ * @public
+ *
+ * @deprecated Use the following import instead:
+ *
+ * ```ts
+ * import { defineText } from 'prosekit/extensions/text'
+ * ```
+ */
+export function defineText(): TextExtension {
+  console.warn(
+    '[prosekit] The `defineText` function from `prosekit/core` is deprecated. Use the following import instead: `import { defineText } from "prosekit/extensions/text"`.',
+  )
+
+  return defineNodeSpec({
+    name: 'text',
+    group: 'inline',
+  })
+}

package/src/facets/base-extension.ts

@@ -0,0 +1,54 @@
+import type { Schema } from '@prosekit/pm/model'
+
+import type {
+  Extension,
+  ExtensionTyping,
+} from '../types/extension'
+import { Priority } from '../types/priority'
+
+import type { Facet } from './facet'
+import type { FacetNode } from './facet-node'
+import type { Tuple5 } from './facet-types'
+import { schemaFacet } from './schema'
+
+/**
+ * @internal
+ */
+export abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
+  abstract extension: Extension | Extension[]
+  priority?: Priority
+  _type?: T
+
+  private trees: Tuple5<FacetNode | null> = [null, null, null, null, null]
+
+  /**
+   * @internal
+   */
+  abstract createTree(priority: Priority): FacetNode
+
+  /**
+   * @internal
+   */
+  getTree(priority?: Priority): FacetNode {
+    const pri = priority ?? this.priority ?? Priority.default
+    return (this.trees[pri] ||= this.createTree(pri))
+  }
+
+  /**
+   * @internal
+   */
+  findFacetOutput<I, O>(facet: Facet<I, O>): Tuple5<O | null> | null {
+    let node: FacetNode | undefined = this.getTree()
+
+    for (const index of facet.path) {
+      node = node?.children.get(index)
+    }
+
+    return node?.getOutput() ?? null
+  }
+
+  get schema(): Schema | null {
+    const output = this.findFacetOutput(schemaFacet)
+    return output?.find(Boolean)?.schema ?? null
+  }
+}

package/src/facets/command.ts

@@ -0,0 +1,21 @@
+import type { CommandCreators } from '../types/extension-command'
+
+import {
+  defineFacet,
+  type Facet,
+} from './facet'
+import {
+  rootFacet,
+  type RootPayload,
+} from './root'
+
+type CommandPayload = CommandCreators
+
+export const commandFacet: Facet<CommandPayload, RootPayload> = defineFacet({
+  reducer: (inputs) => {
+    const commands = Object.assign({}, ...inputs) as CommandPayload
+    return { commands }
+  },
+  parent: rootFacet,
+  singleton: true,
+})

package/src/facets/facet-extension.spec.ts

@@ -0,0 +1,173 @@
+import {
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest'
+
+import { Priority } from '../types/priority'
+import { isNotNullish } from '../utils/type-assertion'
+
+import {
+  defineFacet,
+  Facet,
+} from './facet'
+import { FacetExtensionImpl } from './facet-extension'
+import {
+  subtractFacetNode,
+  unionFacetNode,
+} from './facet-node'
+import type { FacetReducer } from './facet-types'
+import { UnionExtensionImpl } from './union-extension'
+
+describe('facet extension', () => {
+  type FooHandler = (foo: string) => void
+  type BarHandler = (bar: string) => void
+
+  interface RootInput {
+    onFoo?: FooHandler
+    onBar?: BarHandler
+  }
+
+  interface RootOutput {
+    fooHandlers: FooHandler[]
+    barHandlers: BarHandler[]
+  }
+
+  type FooInput = FooHandler
+  type BarInput = BarHandler
+
+  const rootReducerImpl: FacetReducer<RootInput, RootOutput> = (input) => {
+    const fooHandlers = input.map((i) => i.onFoo).filter(isNotNullish)
+    const barHandlers = input.map((i) => i.onBar).filter(isNotNullish)
+    return { fooHandlers, barHandlers }
+  }
+  const rootReducer = vi.fn(rootReducerImpl)
+  const rootFacet = new Facet(null, true, rootReducer)
+
+  // Foo facet uses `reduce` closure to return the same `onFoo` function every time.
+  const fooReduce: () => FacetReducer<FooInput, RootInput> = () => {
+    let fooHandlers: FooHandler[] | undefined
+
+    const onFoo = (value: string): void => {
+      fooHandlers?.forEach((handler) => handler(value))
+    }
+
+    return (input) => {
+      fooHandlers = input
+      return { onFoo }
+    }
+  }
+  const fooFacet = defineFacet<FooInput, RootInput>({
+    parent: rootFacet,
+    reduce: fooReduce,
+  })
+
+  // Bar facet uses `reducer` directly thus the `onBar` function is a different instance every time.
+  const barReducer: FacetReducer<BarInput, RootInput> = (input) => {
+    return {
+      onBar: (value: string) => {
+        input.forEach((handler) => handler(value))
+      },
+    }
+  }
+  const barFacet = defineFacet<BarInput, RootInput>({
+    parent: rootFacet,
+    reducer: barReducer,
+  })
+
+  it('can merge payloads', () => {
+    const fooHandler1: FooHandler = vi.fn()
+    const fooExtension1 = new FacetExtensionImpl(fooFacet, [fooHandler1])
+
+    const fooHandler2: FooHandler = vi.fn()
+    const fooExtension2 = new FacetExtensionImpl(fooFacet, [fooHandler2])
+
+    const barHandler1: BarHandler = vi.fn()
+    const barExtension1 = new FacetExtensionImpl(barFacet, [barHandler1])
+
+    const extension1 = new UnionExtensionImpl([
+      fooExtension1,
+      fooExtension2,
+      barExtension1,
+    ])
+
+    const tree = extension1.createTree(Priority.default)
+    const rootOutput = tree.getSingletonOutput() as RootOutput
+    expect(rootOutput.fooHandlers).toHaveLength(1)
+    expect(rootOutput.barHandlers).toHaveLength(1)
+
+    expect(fooHandler1).toHaveBeenCalledTimes(0)
+    expect(fooHandler2).toHaveBeenCalledTimes(0)
+    expect(barHandler1).toHaveBeenCalledTimes(0)
+
+    rootOutput.fooHandlers.forEach((handler) => handler('a'))
+    expect(fooHandler1).toHaveBeenCalledWith('a')
+    expect(fooHandler1).toHaveBeenCalledTimes(1)
+    expect(fooHandler2).toHaveBeenCalledWith('a')
+    expect(fooHandler2).toHaveBeenCalledTimes(1)
+
+    rootOutput.barHandlers.forEach((handler) => handler('b'))
+    expect(barHandler1).toHaveBeenCalledWith('b')
+    expect(barHandler1).toHaveBeenCalledTimes(1)
+  })
+
+  it('can skip unnecessary update', () => {
+    const fooHandler1: FooHandler = vi.fn()
+    const fooExtension1 = new FacetExtensionImpl(fooFacet, [fooHandler1])
+
+    const fooHandler2: FooHandler = vi.fn()
+    const fooExtension2 = new FacetExtensionImpl(fooFacet, [fooHandler2])
+
+    const barHandler1: BarHandler = vi.fn()
+    const barExtension1 = new FacetExtensionImpl(barFacet, [barHandler1])
+
+    const barHandler2: BarHandler = vi.fn()
+    const barExtension2 = new FacetExtensionImpl(barFacet, [barHandler2])
+
+    // Initial the root output with fooExtension1 and barExtension1.
+    const rootExtension = new UnionExtensionImpl([fooExtension1, barExtension1])
+    let tree = rootExtension.createTree(Priority.default)
+    let rootOutput = tree.getSingletonOutput() as RootOutput
+
+    // Save the initial root output.
+    const rootFooHandlers1 = [...rootOutput.fooHandlers]
+    const rootBarHandlers1 = [...rootOutput.barHandlers]
+
+    // Add fooExtension2.
+    // This should not trigger any updates to the root output.
+    tree = unionFacetNode(tree, fooExtension2.getTree())
+    rootOutput = tree.getSingletonOutput() as RootOutput
+    const rootFooHandlers2 = [...rootOutput.fooHandlers]
+    const rootBarHandlers2 = [...rootOutput.barHandlers]
+    expect(rootFooHandlers2).toEqual(rootFooHandlers1)
+    expect(rootBarHandlers2).toEqual(rootBarHandlers1)
+
+    // Add barExtension2.
+    // This should change rootOutput.barHandlers
+    tree = unionFacetNode(tree, barExtension2.getTree())
+    rootOutput = tree.getSingletonOutput() as RootOutput
+    const rootFooHandlers3 = [...rootOutput.fooHandlers]
+    const rootBarHandlers3 = [...rootOutput.barHandlers]
+    expect(rootFooHandlers3).toEqual(rootFooHandlers2)
+    expect(rootBarHandlers3).not.toEqual(rootBarHandlers2)
+
+    // Remove fooExtension1
+    // This should not trigger any updates to the root output.
+    tree = subtractFacetNode(tree, fooExtension1.getTree())
+    rootOutput = tree.getSingletonOutput() as RootOutput
+    const rootFooHandlers4 = [...rootOutput.fooHandlers]
+    const rootBarHandlers4 = [...rootOutput.barHandlers]
+    expect(rootFooHandlers4).toEqual(rootFooHandlers3)
+    expect(rootBarHandlers4).toEqual(rootBarHandlers3)
+
+    // Remove barExtension2
+    // This should change rootOutput.barHandlers
+    tree = subtractFacetNode(tree, barExtension2.getTree())
+    rootOutput = tree.getSingletonOutput() as RootOutput
+    const rootFooHandlers5 = [...rootOutput.fooHandlers]
+    const rootBarHandlers5 = [...rootOutput.barHandlers]
+    expect(rootFooHandlers5).toEqual(rootFooHandlers4)
+    expect(rootBarHandlers5).not.toEqual(rootBarHandlers4)
+  })
+})

package/src/facets/facet-extension.ts

@@ -0,0 +1,53 @@
+import type { Extension } from '../types/extension'
+import type { Priority } from '../types/priority'
+
+import { BaseExtension } from './base-extension'
+import type { Facet } from './facet'
+import { FacetNode } from './facet-node'
+import type { Tuple5 } from './facet-types'
+
+/**
+ * @internal
+ */
+export class FacetExtensionImpl<Input, Output> extends BaseExtension {
+  declare extension: Extension
+
+  /**
+   * @internal
+   */
+  constructor(
+    readonly facet: Facet<Input, Output>,
+    readonly payloads: Input[],
+  ) {
+    super()
+  }
+
+  /**
+   * @internal
+   */
+  createTree(priority: Priority): FacetNode {
+    const pri = this.priority ?? priority
+
+    const inputs: Tuple5<Input[] | null> = [null, null, null, null, null]
+    inputs[pri] = [...this.payloads]
+
+    let node: FacetNode = new FacetNode(this.facet, inputs)
+
+    while (node.facet.parent) {
+      const children = new Map([[node.facet.index, node]])
+      node = new FacetNode(node.facet.parent, undefined, children)
+    }
+
+    return node
+  }
+}
+
+/**
+ * @internal
+ */
+export function defineFacetPayload<Input>(
+  facet: Facet<Input, any>,
+  payloads: Input[],
+): Extension {
+  return new FacetExtensionImpl(facet, payloads)
+}

package/src/facets/facet-node.spec.ts

@@ -0,0 +1,265 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { Priority } from '../types/priority'
+
+import { Facet } from './facet'
+import {
+  FacetNode,
+  subtractFacetNode,
+  unionFacetNode,
+} from './facet-node'
+
+const sum = (input: number[]) => input.reduce((acc, cur) => acc + cur, 0)
+
+const CounterFacet = new Facet<number, number>(null, false, sum)
+const SingletonCounterFacet = new Facet<number, number>(null, true, sum)
+
+const value1 = [0, 1, 2]
+const value2 = [3, 4, 5]
+const value3 = [6, 7, 8]
+
+test('Root Facet Node', () => {
+  const rootNode = new FacetNode(CounterFacet, [
+    [...value1],
+    null,
+    null,
+    [...value1],
+    null,
+  ])
+  const childNode1 = new FacetNode(CounterFacet, [
+    null,
+    [...value2],
+    null,
+    [...value2],
+    null,
+  ])
+  const childNode2 = new FacetNode(CounterFacet, [
+    null,
+    null,
+    [...value3],
+    [...value3],
+    null,
+  ])
+
+  rootNode.children.set(0, childNode1)
+  rootNode.children.set(1, childNode2)
+
+  expect(rootNode.facet).toBe(CounterFacet)
+  expect(rootNode.children.size).toBe(2)
+  expect(rootNode.getOutput()).toEqual([
+    sum(value1),
+    sum(value2),
+    sum(value3),
+    sum([...value1, ...value2, ...value3]),
+    null,
+  ])
+  expect(() => rootNode.getRootOutput()).toThrow()
+  expect(rootNode.isRoot()).toBeTruthy()
+})
+
+test('Singleton Root Facet Node', () => {
+  const singletonRootNode = new FacetNode(SingletonCounterFacet, [
+    [...value1],
+    null,
+    null,
+    null,
+    null,
+  ])
+  const childNode1 = new FacetNode(CounterFacet, [
+    null,
+    [...value2],
+    null,
+    [...value2],
+    null,
+  ])
+  const childNode2 = new FacetNode(CounterFacet, [
+    null,
+    null,
+    [...value3],
+    [...value3],
+    null,
+  ])
+
+  singletonRootNode.children.set(0, childNode1)
+  singletonRootNode.children.set(1, childNode2)
+
+  expect(singletonRootNode.facet).toBe(SingletonCounterFacet)
+  expect(singletonRootNode.children.size).toBe(2)
+  expect(childNode1.getOutput()).toEqual([
+    null,
+    sum(value2),
+    null,
+    sum(value2),
+    null,
+  ])
+  expect(childNode2.getOutput()).toEqual([
+    null,
+    null,
+    sum(value3),
+    sum(value3),
+    null,
+  ])
+  expect(singletonRootNode.getOutput()).toEqual([
+    null,
+    null,
+    sum([...value1, sum(value2), sum(value3), ...[sum(value2), sum(value3)]]),
+    null,
+    null,
+  ])
+  expect(singletonRootNode.getRootOutput()).toEqual(
+    singletonRootNode.getOutput()[Priority.default],
+  )
+})
+
+test('Union Facet Node', () => {
+  const rootNode1 = new FacetNode(CounterFacet, [
+    [...value1],
+    null,
+    null,
+    [...value1, ...value3],
+    null,
+  ])
+  const rootNode2 = new FacetNode(CounterFacet, [
+    null,
+    [...value1],
+    null,
+    [...value1, ...value2],
+    null,
+  ])
+  const childNode1 = new FacetNode(CounterFacet, [
+    null,
+    null,
+    [...value2],
+    [...value2],
+    null,
+  ])
+  const childNode2 = new FacetNode(CounterFacet, [
+    null,
+    null,
+    [...value3],
+    [...value3],
+    null,
+  ])
+
+  rootNode1.children.set(0, childNode1)
+  rootNode2.children.set(0, childNode2)
+
+  const unioned = unionFacetNode(rootNode1, rootNode2)
+  expect(unioned.facet).toBe(CounterFacet)
+  expect(unioned.children.size).toBe(1)
+  expect(unioned.children.get(0)).toEqual(
+    unionFacetNode(childNode1, childNode2),
+  )
+  expect(unioned.inputs).toEqual([
+    [...value1],
+    [...value1],
+    null,
+    [...value1, ...value3, ...value2],
+    null,
+  ])
+  expect(unioned.children.get(0)?.inputs).toEqual([
+    null,
+    null,
+    [...value2, ...value3],
+    [...value2, ...value3],
+    null,
+  ])
+})
+
+test('Subtract Facet Node', () => {
+  const rootNode1 = new FacetNode(CounterFacet, [
+    [...value1],
+    null,
+    null,
+    [...value1, ...value3],
+    null,
+  ])
+  const rootNode2 = new FacetNode(CounterFacet, [
+    null,
+    [...value1],
+    null,
+    [...value1, ...value2],
+    null,
+  ])
+  const childNode1 = new FacetNode(CounterFacet, [
+    null,
+    null,
+    [...value2],
+    [...value2],
+    null,
+  ])
+  const childNode2 = new FacetNode(CounterFacet, [
+    null,
+    null,
+    [...value2],
+    [...value3],
+    null,
+  ])
+
+  rootNode1.children.set(0, childNode1)
+  rootNode2.children.set(0, childNode2)
+
+  const subtracted = subtractFacetNode(rootNode1, rootNode2)
+  expect(subtracted.facet).toBe(CounterFacet)
+  expect(subtracted.children.size).toBe(1)
+  expect(subtracted.children.get(0)).toEqual(
+    subtractFacetNode(childNode1, childNode2),
+  )
+
+  expect(subtracted.inputs).toEqual([
+    [...value1],
+    null,
+    null,
+    [...value3],
+    null,
+  ])
+
+  expect(subtracted.children.get(0)?.inputs).toEqual([
+    null,
+    null,
+    [],
+    [...value2],
+    null,
+  ])
+})
+
+test('Union Facet Node with Different Facet', () => {
+  const rootNode1 = new FacetNode(CounterFacet, [
+    [...value1],
+    null,
+    null,
+    [...value1, ...value3],
+    null,
+  ])
+  const rootNode2 = new FacetNode(SingletonCounterFacet, [
+    null,
+    [...value1],
+    null,
+    [...value1, ...value2],
+    null,
+  ])
+
+  expect(() => unionFacetNode(rootNode1, rootNode2)).toThrow()
+})
+
+test('Subtract Facet Node with Different Facet', () => {
+  const rootNode1 = new FacetNode(CounterFacet, [
+    [...value1],
+    null,
+    null,
+    [...value1, ...value3],
+    null,
+  ])
+  const rootNode2 = new FacetNode(SingletonCounterFacet, [
+    null,
+    [...value1],
+    null,
+    [...value1, ...value2],
+    null,
+  ])
+
+  expect(() => subtractFacetNode(rootNode1, rootNode2)).toThrow()
+})