@prosekit/core 0.8.3 → 0.8.5

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()
+})

package/src/facets/facet-node.ts

@@ -0,0 +1,185 @@
+import { Priority } from '../types/priority'
+import {
+  arraySubtract,
+  uniqPush,
+} from '../utils/array'
+import { assert } from '../utils/assert'
+import { isNotNullish } from '../utils/type-assertion'
+
+import type { Facet } from './facet'
+import type {
+  FacetReducer,
+  Tuple5,
+} from './facet-types'
+import type { RootOutput } from './root'
+
+function zip5<T>(
+  a: Tuple5<T>,
+  b: Tuple5<T>,
+  mapper: (a: T, b: T) => T,
+): Tuple5<T> {
+  return [
+    mapper(a[0], b[0]),
+    mapper(a[1], b[1]),
+    mapper(a[2], b[2]),
+    mapper(a[3], b[3]),
+    mapper(a[4], b[4]),
+  ]
+}
+
+function unionInput<T>(a: T[] | null, b: T[] | null): T[] | null {
+  if (!a && !b) return null
+  return uniqPush(a ?? [], b ?? [])
+}
+
+function subtractInput<T>(a: T[] | null, b: T[] | null): T[] | null {
+  if (!a) return null
+  if (!b) return [...a]
+  return arraySubtract(a, b)
+}
+
+function unionChildren(
+  a: Map<number, FacetNode>,
+  b: Map<number, FacetNode>,
+): Map<number, FacetNode> {
+  const merged = new Map(a)
+  for (const [key, valueB] of b.entries()) {
+    const valueA = a.get(key)
+    merged.set(key, valueA ? unionFacetNode(valueA, valueB) : valueB)
+  }
+  return merged
+}
+
+function subtractChildren(
+  a: Map<number, FacetNode>,
+  b: Map<number, FacetNode>,
+): Map<number, FacetNode> {
+  const merged = new Map(a)
+  for (const [key, valueB] of b.entries()) {
+    const valueA = a.get(key)
+    if (valueA) {
+      merged.set(key, subtractFacetNode(valueA, valueB))
+    }
+  }
+  return merged
+}
+
+/**
+ * Takes two facet nodes and returns a new facet node containing inputs and
+ * children from both nodes.
+ *
+ * The reducers of the first facet node will be reused.
+ *
+ * @internal
+ */
+export function unionFacetNode<I, O>(
+  a: FacetNode<I, O>,
+  b: FacetNode<I, O>,
+): FacetNode<I, O> {
+  assert(a.facet === b.facet)
+  return new FacetNode(
+    a.facet,
+    zip5(a.inputs, b.inputs, unionInput),
+    unionChildren(a.children, b.children),
+    a.reducers,
+  )
+}
+
+/**
+ * Takes two facet nodes and returns a new facet node containing inputs and
+ * children from the first node but not the second.
+ *
+ * The reducers of the first facet node will be reused.
+ *
+ * @internal
+ */
+export function subtractFacetNode<I, O>(
+  a: FacetNode<I, O>,
+  b: FacetNode<I, O>,
+): FacetNode<I, O> {
+  assert(a.facet === b.facet)
+  return new FacetNode(
+    a.facet,
+    zip5(a.inputs, b.inputs, subtractInput),
+    subtractChildren(a.children, b.children),
+    a.reducers,
+  )
+}
+
+export class FacetNode<I = any, O = any> {
+  output: Tuple5<O | null> | null = null
+
+  constructor(
+    readonly facet: Facet<I, O>,
+    readonly inputs: Tuple5<I[] | null> = [null, null, null, null, null],
+    readonly children: Map<number, FacetNode> = new Map(),
+    readonly reducers: Tuple5<FacetReducer<I, O> | null> = [
+      null,
+      null,
+      null,
+      null,
+      null,
+    ],
+  ) {}
+
+  private calcOutput(): Tuple5<O | null> {
+    const inputs: Tuple5<I[] | null> = [null, null, null, null, null]
+    const output: Tuple5<O | null> = [null, null, null, null, null]
+
+    for (let pri = 0; pri < 5; pri++) {
+      const input = this.inputs[pri]
+      if (input) {
+        inputs[pri] = [...input]
+      }
+    }
+
+    for (const child of this.children.values()) {
+      const childOutput = child.getOutput()
+      for (let pri = 0; pri < 5; pri++) {
+        if (childOutput[pri]) {
+          const input = (inputs[pri] ||= [])
+          input.push(childOutput[pri] as I)
+        }
+      }
+    }
+
+    if (this.facet.singleton) {
+      const reducer = (this.reducers[Priority.default] ||= this.facet.reducer)
+      const input: I[] = inputs.filter(isNotNullish).flat()
+      output[Priority.default] = reducer(input)
+    } else {
+      for (let pri = 0; pri < 5; pri++) {
+        const input = inputs[pri]
+        if (input) {
+          const reducer = (this.reducers[pri] ||= this.facet.reducer)
+          output[pri] = reducer(input)
+        }
+      }
+    }
+
+    return output
+  }
+
+  getOutput(): Tuple5<O | null> {
+    if (!this.output) {
+      this.output = this.calcOutput()
+    }
+    return this.output
+  }
+
+  getSingletonOutput(): O | null {
+    assert(this.facet.singleton)
+    return this.getOutput()[Priority.default]
+  }
+
+  getRootOutput(): RootOutput {
+    assert(this.isRoot())
+    const output = this.getSingletonOutput()
+    assert(output)
+    return output
+  }
+
+  isRoot(): boolean {
+    return !this.facet.parent
+  }
+}

package/src/facets/facet-types.ts

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ */
+export type Tuple5<T> = [T, T, T, T, T]
+
+/**
+ * @internal
+ */
+export type FacetReducer<Input, Output> = (input: Input[]) => Output

package/src/facets/facet.spec.ts

@@ -0,0 +1,76 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { Facet } from './facet'
+
+type RootInput = {
+  count: number
+}
+type RootOutput = {
+  count: number
+  id: symbol
+}
+const id = Symbol('root-facet')
+const rootFacet = new Facet<RootInput, RootOutput>(null, true, (input) => {
+  const count = input
+    .map(({ count }) => count)
+    .reduce((acc, cur) => {
+      return acc + cur
+    }, 0)
+
+  return {
+    count,
+    id,
+  }
+})
+
+const doubleFacet = new Facet<RootOutput, RootOutput>(
+  rootFacet,
+  false,
+  (input) => {
+    const id = input[0].id
+    const count = input
+      .map(({ count }) => count)
+      .reduce((acc, cur) => {
+        return acc + cur
+      }, 0)
+
+    return {
+      count: count * 2,
+      id,
+    }
+  },
+)
+
+test('Root Facet', () => {
+  expect(rootFacet.parent).toBe(null)
+  expect(rootFacet.singleton).toBe(true)
+  expect(rootFacet.path).toEqual([])
+  expect(
+    rootFacet.reducer([
+      { count: 1 },
+      { count: 2 },
+      { count: 3 },
+      { count: 4 },
+      { count: 0 },
+    ]),
+  ).toEqual({ count: 10, id })
+})
+
+test('Child Facet', () => {
+  expect(doubleFacet.parent).toBe(rootFacet)
+  expect(doubleFacet.singleton).toBe(false)
+  expect(doubleFacet.path).toEqual([1])
+  expect(
+    doubleFacet.reducer([
+      { count: 1, id },
+      { count: 2, id },
+      { count: 3, id },
+    ]),
+  ).toEqual({
+    count: 12,
+    id,
+  })
+})

package/src/facets/facet.ts

@@ -0,0 +1,84 @@
+import { assert } from '../utils/assert'
+
+import type { FacetReducer } from './facet-types'
+
+let facetCount = 0
+
+/**
+ * @internal
+ */
+export class Facet<Input, Output> {
+  /**
+   * @internal
+   */
+  readonly index: number = facetCount++
+  /**
+   * @internal
+   */
+  readonly parent: Facet<Output, any> | null
+  /**
+   * @internal
+   */
+  readonly singleton: boolean
+  /**
+   * A index path to retrieve the current facet in a tree from the root.
+   *
+   * @internal
+   */
+  readonly path: number[]
+
+  /**
+   * @internal
+   */
+  constructor(
+    parent: Facet<Output, any> | null,
+    singleton: boolean,
+    private _reducer?: FacetReducer<Input, Output> | undefined,
+    private _reduce?: () => FacetReducer<Input, Output>,
+  ) {
+    // Only one of _reducer or _reduce can be defined
+    assert((_reduce || _reducer) && !(_reduce && _reducer))
+
+    this.parent = parent
+    this.singleton = singleton
+    this.path = parent ? [...parent.path, this.index] : []
+  }
+
+  get reducer(): FacetReducer<Input, Output> {
+    return (this._reducer ?? this._reduce?.())!
+  }
+}
+
+/**
+ * @internal
+ */
+export function defineFacet<Input, Output>(options: {
+  /**
+   * The parent facet in the tree.
+   */
+  parent: Facet<Output, any>
+
+  /**
+   * Set this to true if you only want to keep one facet payload. For example,
+   * this facet corresponds to a ProseMirror plugin with a key.
+   */
+  singleton?: boolean
+
+  /**
+   * A reducer is a function that accepts an array of input and produce a single
+   * output.
+   */
+  reducer?: FacetReducer<Input, Output>
+  /**
+   * A callback function that returns a reducer. This is useful if you want to
+   * store something in the closure.
+   */
+  reduce?: () => FacetReducer<Input, Output>
+}): Facet<Input, Output> {
+  return new Facet(
+    options.parent,
+    options.singleton ?? false,
+    options.reducer,
+    options.reduce,
+  )
+}

package/src/facets/root.ts

@@ -0,0 +1,44 @@
+import type { Schema } from '@prosekit/pm/model'
+import type { EditorStateConfig } from '@prosekit/pm/state'
+import type { DirectEditorProps } from '@prosekit/pm/view'
+
+import type { CommandCreators } from '../types/extension-command'
+
+import { Facet } from './facet'
+
+export type RootPayload = {
+  schema?: Schema | null
+  commands?: CommandCreators
+  state?: (ctx: { schema: Schema }) => EditorStateConfig
+  view?: Omit<DirectEditorProps, 'state'>
+}
+
+export type RootOutput = {
+  schema?: Schema | null
+  commands?: CommandCreators
+  state?: EditorStateConfig
+  view?: Omit<DirectEditorProps, 'state'>
+}
+
+function rootReducer(inputs: RootPayload[]): RootOutput {
+  let schema: Schema | undefined
+  let commands: CommandCreators | undefined
+  let stateFunc: ((ctx: { schema: Schema }) => EditorStateConfig) | undefined
+  let view: Omit<DirectEditorProps, 'state'> | undefined
+
+  for (const input of inputs) {
+    schema = input.schema || schema
+    commands = input.commands || commands
+    stateFunc = input.state || stateFunc
+    view = input.view || view
+  }
+
+  const state = schema && (stateFunc?.({ schema }) ?? { schema })
+
+  return { schema, state, commands, view }
+}
+
+export const rootFacet: Facet<RootPayload, RootOutput> = new Facet<
+  RootPayload,
+  RootOutput
+>(null, true, rootReducer)

package/src/facets/schema-spec.ts

@@ -0,0 +1,30 @@
+import type {
+  MarkSpec,
+  NodeSpec,
+  SchemaSpec,
+} from '@prosekit/pm/model'
+import OrderedMap from 'orderedmap'
+
+import {
+  defineFacet,
+  type Facet,
+} from './facet'
+import { schemaFacet } from './schema'
+
+export const schemaSpecFacet: Facet<SchemaSpec, SchemaSpec> = defineFacet({
+  reducer: (specs): SchemaSpec => {
+    let nodes = OrderedMap.from<NodeSpec>({})
+    let marks = OrderedMap.from<MarkSpec>({})
+    let topNode: string | undefined = undefined
+
+    for (const spec of specs) {
+      nodes = nodes.append(spec.nodes)
+      marks = marks.append(spec.marks ?? {})
+      topNode = topNode ?? spec.topNode
+    }
+
+    return { nodes, marks, topNode }
+  },
+  parent: schemaFacet,
+  singleton: true,
+})

package/src/facets/schema.ts

@@ -0,0 +1,26 @@
+import {
+  Schema,
+  type SchemaSpec,
+} from '@prosekit/pm/model'
+
+import { assert } from '../utils/assert'
+
+import {
+  defineFacet,
+  type Facet,
+} from './facet'
+import {
+  rootFacet,
+  type RootPayload,
+} from './root'
+
+export const schemaFacet: Facet<SchemaSpec, RootPayload> = defineFacet({
+  reducer: (specs) => {
+    assert(specs.length <= 1)
+    const spec = specs[0]
+    const schema = spec ? new Schema(spec) : null
+    return { schema }
+  },
+  parent: rootFacet,
+  singleton: true,
+})