@jvs-milkdown/core 1.0.0

package/src/internal-plugin/parser.ts

@@ -0,0 +1,51 @@
+import type { MilkdownPlugin, TimerType } from '@jvs-milkdown/ctx'
+import type { Parser } from '@jvs-milkdown/transformer'
+
+import { createSlice, createTimer } from '@jvs-milkdown/ctx'
+import { ctxCallOutOfScope } from '@jvs-milkdown/exception'
+import { ParserState } from '@jvs-milkdown/transformer'
+
+import { withMeta } from '../__internal__'
+import { remarkCtx } from './atoms'
+import { SchemaReady, schemaCtx } from './schema'
+
+/// The timer which will be resolved when the parser plugin is ready.
+export const ParserReady = createTimer('ParserReady')
+
+const outOfScope = (() => {
+  throw ctxCallOutOfScope()
+}) as Parser
+
+/// A slice which contains the parser.
+export const parserCtx = createSlice(outOfScope, 'parser')
+
+/// A slice which stores timers that need to be waited for before starting to run the plugin.
+/// By default, it's `[SchemaReady]`.
+export const parserTimerCtx = createSlice([] as TimerType[], 'parserTimer')
+
+/// The parser plugin.
+/// This plugin will create a parser.
+///
+/// This plugin will wait for the schema plugin.
+export const parser: MilkdownPlugin = (ctx) => {
+  ctx
+    .inject(parserCtx, outOfScope)
+    .inject(parserTimerCtx, [SchemaReady])
+    .record(ParserReady)
+
+  return async () => {
+    await ctx.waitTimers(parserTimerCtx)
+    const remark = ctx.get(remarkCtx)
+    const schema = ctx.get(schemaCtx)
+
+    ctx.set(parserCtx, ParserState.create(schema, remark))
+    ctx.done(ParserReady)
+    return () => {
+      ctx.remove(parserCtx).remove(parserTimerCtx).clearTimer(ParserReady)
+    }
+  }
+}
+
+withMeta(parser, {
+  displayName: 'Parser',
+})

package/src/internal-plugin/paste-rule.ts

@@ -0,0 +1,53 @@
+import type { Slice } from '@jvs-milkdown/prose/model'
+import type { EditorView } from '@jvs-milkdown/prose/view'
+
+import { createSlice, createTimer, type MilkdownPlugin } from '@jvs-milkdown/ctx'
+
+import { withMeta } from '../__internal__'
+import { SchemaReady } from './schema'
+
+/// A paste rule function which takes a slice and returns a new slice.
+export type PasteRule = {
+  /// The function to run the paste rule.
+  run: (slice: Slice, view: EditorView, isPlainText: boolean) => Slice
+  /// The priority of the paste rule. Higher priority rules will be run first. Default is 50.
+  priority?: number
+}
+
+/// A slice which contains the paste rules.
+export const pasteRulesCtx = createSlice([] as PasteRule[], 'pasteRule')
+
+/// A slice which stores timers that need to be waited for before starting to run the paste rule plugin.
+/// By default, it's `[SchemaReady]`.
+export const pasteRulesTimerCtx = createSlice([SchemaReady], 'pasteRuleTimer')
+
+/// The timer which will be resolved when the paste rule plugin is ready.
+export const PasteRulesReady = createTimer('PasteRuleReady')
+
+/// The paste rule plugin.
+/// This plugin will collect the paste rules to the editor view.
+///
+/// This plugin will wait for the schema plugin.
+export const pasteRule: MilkdownPlugin = (ctx) => {
+  ctx
+    .inject(pasteRulesCtx, [])
+    .inject(pasteRulesTimerCtx, [SchemaReady])
+    .record(PasteRulesReady)
+
+  return async () => {
+    await ctx.waitTimers(pasteRulesTimerCtx)
+
+    ctx.done(PasteRulesReady)
+
+    return () => {
+      ctx
+        .remove(pasteRulesCtx)
+        .remove(pasteRulesTimerCtx)
+        .clearTimer(PasteRulesReady)
+    }
+  }
+}
+
+withMeta(pasteRule, {
+  displayName: 'PasteRule',
+})

package/src/internal-plugin/schema.ts

@@ -0,0 +1,88 @@
+import type { MilkdownPlugin, TimerType } from '@jvs-milkdown/ctx'
+import type {
+  MarkSchema,
+  NodeSchema,
+  RemarkParser,
+} from '@jvs-milkdown/transformer'
+
+import { createSlice, createTimer } from '@jvs-milkdown/ctx'
+import { Schema } from '@jvs-milkdown/prose/model'
+
+import { withMeta } from '../__internal__'
+import { remarkCtx, remarkPluginsCtx } from './atoms'
+import { InitReady } from './init'
+
+/// The timer which will be resolved when the schema plugin is ready.
+export const SchemaReady = createTimer('SchemaReady')
+
+/// A slice which stores timers that need to be waited for before starting to run the plugin.
+/// By default, it's `[InitReady]`.
+export const schemaTimerCtx = createSlice([] as TimerType[], 'schemaTimer')
+
+/// A slice which contains the schema.
+export const schemaCtx = createSlice({} as Schema, 'schema')
+
+/// A slice which stores the nodes spec.
+export const nodesCtx = createSlice([] as Array<[string, NodeSchema]>, 'nodes')
+
+/// A slice which stores the marks spec.
+export const marksCtx = createSlice([] as Array<[string, MarkSchema]>, 'marks')
+
+function extendPriority<T extends NodeSchema | MarkSchema>(x: T): T {
+  return {
+    ...x,
+    parseDOM: x.parseDOM?.map((rule) => ({ priority: x.priority, ...rule })),
+  }
+}
+
+/// The schema plugin.
+/// This plugin will load all nodes spec and marks spec and create a schema.
+///
+/// This plugin will wait for the init plugin.
+export const schema: MilkdownPlugin = (ctx) => {
+  ctx
+    .inject(schemaCtx, {} as Schema)
+    .inject(nodesCtx, [])
+    .inject(marksCtx, [])
+    .inject(schemaTimerCtx, [InitReady])
+    .record(SchemaReady)
+
+  return async () => {
+    await ctx.waitTimers(schemaTimerCtx)
+
+    const remark = ctx.get(remarkCtx)
+    const remarkPlugins = ctx.get(remarkPluginsCtx)
+
+    const processor = remarkPlugins.reduce(
+      (acc: RemarkParser, plug) =>
+        acc.use(plug.plugin, plug.options) as unknown as RemarkParser,
+      remark
+    )
+    ctx.set(remarkCtx, processor)
+
+    const nodes = Object.fromEntries(
+      ctx.get(nodesCtx).map(([key, x]) => [key, extendPriority(x)])
+    )
+    const marks = Object.fromEntries(
+      ctx.get(marksCtx).map(([key, x]) => [key, extendPriority(x)])
+    )
+    const schema = new Schema({ nodes, marks })
+
+    ctx.set(schemaCtx, schema)
+
+    ctx.done(SchemaReady)
+
+    return () => {
+      ctx
+        .remove(schemaCtx)
+        .remove(nodesCtx)
+        .remove(marksCtx)
+        .remove(schemaTimerCtx)
+        .clearTimer(SchemaReady)
+    }
+  }
+}
+
+withMeta(schema, {
+  displayName: 'Schema',
+})

package/src/internal-plugin/serializer.ts

@@ -0,0 +1,61 @@
+import type { MilkdownPlugin, TimerType } from '@jvs-milkdown/ctx'
+import type { Serializer } from '@jvs-milkdown/transformer'
+
+import { createSlice, createTimer } from '@jvs-milkdown/ctx'
+import { ctxCallOutOfScope } from '@jvs-milkdown/exception'
+import { SerializerState } from '@jvs-milkdown/transformer'
+
+import { withMeta } from '../__internal__'
+import { remarkCtx } from './atoms'
+import { SchemaReady, schemaCtx } from './schema'
+
+/// The timer which will be resolved when the serializer plugin is ready.
+export const SerializerReady = createTimer('SerializerReady')
+
+/// A slice which stores timers that need to be waited for before starting to run the plugin.
+/// By default, it's `[SchemaReady]`.
+export const serializerTimerCtx = createSlice(
+  [] as TimerType[],
+  'serializerTimer'
+)
+
+const outOfScope = (() => {
+  throw ctxCallOutOfScope()
+}) as Serializer
+
+/// A slice which contains the serializer.
+export const serializerCtx = createSlice<Serializer, 'serializer'>(
+  outOfScope,
+  'serializer'
+)
+
+/// The serializer plugin.
+/// This plugin will create a serializer.
+///
+/// This plugin will wait for the schema plugin.
+export const serializer: MilkdownPlugin = (ctx) => {
+  ctx
+    .inject(serializerCtx, outOfScope)
+    .inject(serializerTimerCtx, [SchemaReady])
+    .record(SerializerReady)
+
+  return async () => {
+    await ctx.waitTimers(serializerTimerCtx)
+    const remark = ctx.get(remarkCtx)
+    const schema = ctx.get(schemaCtx)
+
+    ctx.set(serializerCtx, SerializerState.create(schema, remark))
+    ctx.done(SerializerReady)
+
+    return () => {
+      ctx
+        .remove(serializerCtx)
+        .remove(serializerTimerCtx)
+        .clearTimer(SerializerReady)
+    }
+  }
+}
+
+withMeta(serializer, {
+  displayName: 'Serializer',
+})