@prosekit/core 0.8.2 → 0.8.4

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

package/src/facets/state.ts

@@ -0,0 +1,57 @@
+import type { Schema } from '@prosekit/pm/model'
+import type { EditorStateConfig } from '@prosekit/pm/state'
+
+import { uniqPush } from '../utils/array'
+import { assert } from '../utils/assert'
+
+import {
+  defineFacet,
+  type Facet,
+} from './facet'
+import {
+  rootFacet,
+  type RootPayload,
+} from './root'
+
+export type StatePayload = (ctx: { schema: Schema }) => EditorStateConfig
+
+export const stateFacet: Facet<StatePayload, RootPayload> = defineFacet({
+  reduce: () => {
+    let callbacks: StatePayload[] = []
+
+    const state: StatePayload = (ctx) => {
+      const configs = callbacks.map((cb) => cb(ctx))
+      const config: EditorStateConfig = {
+        schema: ctx.schema,
+        storedMarks: [],
+        plugins: [],
+      }
+
+      for (const c of configs) {
+        config.schema = config.schema ?? c.schema
+        config.doc = config.doc ?? c.doc
+        config.selection = config.selection ?? c.selection
+        config.storedMarks = [...config.storedMarks!, ...(c.storedMarks ?? [])]
+        config.plugins = uniqPush(config.plugins ?? [], c.plugins ?? [])
+      }
+
+      assert(
+        config.doc || config.schema,
+        "Can't create state without a schema nor a document",
+      )
+
+      if (config.doc) {
+        config.schema = undefined
+      }
+
+      return config
+    }
+
+    return function reducer(inputs) {
+      callbacks = inputs
+      return { state }
+    }
+  },
+  singleton: true,
+  parent: rootFacet,
+})

package/src/facets/union-extension.ts

@@ -0,0 +1,41 @@
+import type {
+  Extension,
+  ExtensionTyping,
+} from '../types/extension'
+import type { Priority } from '../types/priority'
+import { assert } from '../utils/assert'
+
+import { BaseExtension } from './base-extension'
+import {
+  unionFacetNode,
+  type FacetNode,
+} from './facet-node'
+
+export class UnionExtensionImpl<T extends ExtensionTyping = ExtensionTyping> extends BaseExtension<T> implements Extension<T> {
+  /**
+   * @internal
+   */
+  constructor(public extension: BaseExtension[] = []) {
+    super()
+  }
+
+  /**
+   * @internal
+   */
+  createTree(priority: Priority): FacetNode {
+    const pri = this.priority ?? priority
+
+    const extensions = [...this.extension]
+    extensions.sort((a, b) => (a.priority ?? pri) - (b.priority ?? pri))
+
+    const children: FacetNode[] = extensions.map((ext) => ext.getTree(pri))
+
+    assert(children.length > 0)
+
+    let node = children[0]
+    for (let i = 1; i < children.length; i++) {
+      node = unionFacetNode(node, children[i])
+    }
+    return node
+  }
+}