@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/content.d.ts

@@ -0,0 +1,232 @@
+import { Fragment } from "./fragment.js";
+import { NodeType } from "./schema.js";
+import * as Option from "effect/Option";
+declare namespace content_d_exports {
+  export { ContentExpr, ContentInput, ContentMatch, ExprAST, MatchEdge, Refs, SpecRefs, choice, format, isContentExpr, oneOrMore, optional, parse, ref, repeat, seq, zeroOrMore };
+}
+declare const TypeId = "~effect-richtext/model/ContentExpr";
+/**
+ * The unresolved syntax tree of a content expression.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ExprAST = {
+  readonly _tag: "Choice";
+  readonly exprs: ReadonlyArray<ExprAST>;
+} | {
+  readonly _tag: "Seq";
+  readonly exprs: ReadonlyArray<ExprAST>;
+} | {
+  readonly _tag: "Plus";
+  readonly expr: ExprAST;
+} | {
+  readonly _tag: "Star";
+  readonly expr: ExprAST;
+} | {
+  readonly _tag: "Opt";
+  readonly expr: ExprAST;
+} | {
+  readonly _tag: "Range";
+  readonly min: number;
+  readonly max: number;
+  readonly expr: ExprAST;
+} | {
+  readonly _tag: "Name";
+  readonly name: string;
+};
+/**
+ * A content expression referring to the node or group names `Refs`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ContentExpr<out Refs extends string = string> {
+  readonly [TypeId]: {
+    readonly _Refs: (_: never) => Refs;
+  };
+  readonly ast: ExprAST;
+}
+/**
+ * Anything that can be used where a content expression is expected: an
+ * expression or a bare node/group name.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ContentInput<Refs extends string = string> = ContentExpr<Refs> | Refs;
+/**
+ * Extract the referenced names from a content input.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type Refs<C> = C extends ContentExpr<infer R> ? R : C extends string ? C : never;
+type SyntaxChar = " " | "+" | "*" | "?" | "|" | "(" | ")" | "{" | "}" | ",";
+/**
+ * The names referenced by a spec's `content` field. Plain strings are
+ * ProseMirror content-expression syntax: a bare name is tracked
+ * precisely, anything more complex (`"paragraph+"`) is untyped
+ * (`string`).
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type SpecRefs<C> = C extends ContentExpr<infer R> ? R : C extends `${string}${SyntaxChar}${string}` ? string : C extends string ? C : never;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+export declare const isContentExpr: (u: unknown) => u is ContentExpr<string>;
+/**
+ * Reference a single node type or group by name.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const ref: <const Name extends string>(name: Name) => ContentExpr<Name>;
+/**
+ * A sequence of expressions that must appear in order.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const seq: <const Items extends ReadonlyArray<ContentInput<string>>>(...items: Items) => ContentExpr<Refs<Items[number]>>;
+/**
+ * Any one of the given expressions.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const choice: <const Items extends ReadonlyArray<ContentInput<string>>>(...items: Items) => ContentExpr<Refs<Items[number]>>;
+/**
+ * Zero or more repetitions (`expr*`).
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const zeroOrMore: <const C extends ContentInput<string>>(item: C) => ContentExpr<Refs<C>>;
+/**
+ * One or more repetitions (`expr+`).
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const oneOrMore: <const C extends ContentInput<string>>(item: C) => ContentExpr<Refs<C>>;
+/**
+ * Zero or one occurrence (`expr?`).
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const optional: <const C extends ContentInput<string>>(item: C) => ContentExpr<Refs<C>>;
+/**
+ * Between `min` and `max` repetitions (`expr{min,max}`). When `max` is
+ * omitted it defaults to `min`; pass `Infinity` for no upper bound.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const repeat: <const C extends ContentInput<string>>(item: C, min: number, max?: number) => ContentExpr<Refs<C>>;
+/**
+ * Parse a ProseMirror-style content expression string, such as
+ * `"paragraph block*"`. The referenced names are not tracked at the
+ * type level.
+ *
+ * Syntax errors throw a `SchemaDefinitionError` immediately; unknown names
+ * and other semantic errors are reported when the schema is compiled.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const parse: (source: string) => ContentExpr<string>;
+/**
+ * Render a content expression in ProseMirror's string syntax.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export declare const format: (expr: ContentInput<string>) => string;
+/**
+ * An edge in the content automaton.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MatchEdge {
+  readonly type: NodeType;
+  readonly next: ContentMatch;
+}
+/**
+ * Instances of this class represent a match state of a node type's
+ * content expression, and can be used to find out whether further
+ * content matches here, and whether a given position is a valid end of
+ * the node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class ContentMatch {
+  /** True when this match state represents a valid end of the node. */
+  readonly validEnd: boolean;
+  /** @internal */
+  readonly next: Array<MatchEdge>;
+  /** @internal */
+  readonly wrapCache: Array<NodeType | ReadonlyArray<NodeType> | null>;
+  /** @internal */
+  constructor(
+  /** True when this match state represents a valid end of the node. */
+  validEnd: boolean);
+  /** @internal */
+  static compile(content: ContentInput<string> | undefined, nodeTypes: Readonly<Partial<Record<string, NodeType>>>, typeName: string): ContentMatch;
+  /**
+   * Match a node type, returning a match after that node if
+   * successful.
+   */
+  matchType(type: NodeType): Option.Option<ContentMatch>;
+  /** @internal */
+  matchTypeOrNull(type: NodeType): ContentMatch | null;
+  /** Try to match a fragment. Returns the resulting match when successful. */
+  matchFragment(frag: Fragment, start?: number, end?: number): Option.Option<ContentMatch>;
+  /** @internal */
+  matchFragmentOrNull(frag: Fragment, start?: number, end?: number): ContentMatch | null;
+  /** @internal */
+  get inlineContent(): boolean;
+  /** Get the first matching node type at this match position that can be generated. */
+  get defaultType(): Option.Option<NodeType>;
+  /** @internal */
+  get defaultTypeOrNull(): NodeType | null;
+  /** @internal */
+  compatible(other: ContentMatch): boolean;
+  /**
+   * Try to match the given fragment, and if that fails, see if it can
+   * be made to match by inserting nodes in front of it. When
+   * successful, return a fragment of inserted nodes (which may be
+   * empty if nothing had to be inserted). When `toEnd` is true, only
+   * return a fragment if the resulting match goes to the end of the
+   * content expression.
+   */
+  fillBefore(after: Fragment, toEnd?: boolean, startIndex?: number): Option.Option<Fragment>;
+  /** @internal */
+  fillBeforeOrNull(after: Fragment, toEnd?: boolean, startIndex?: number): Fragment | null;
+  /**
+   * Find a set of wrapping node types that would allow a node of the
+   * given type to appear at this position. The result may be empty
+   * (when it fits directly) and will be `None` when no such wrapping
+   * exists.
+   */
+  findWrapping(target: NodeType): Option.Option<ReadonlyArray<NodeType>>;
+  /** @internal */
+  findWrappingOrNull(target: NodeType): ReadonlyArray<NodeType> | null;
+  /** @internal */
+  computeWrapping(target: NodeType): ReadonlyArray<NodeType> | null;
+  /** The number of outgoing edges this node has in the content automaton. */
+  get edgeCount(): number;
+  /** Get the _n_th outgoing edge from this node in the content automaton. */
+  edge(n: number): Option.Option<MatchEdge>;
+  /** @internal */
+  toString(): string;
+  /** The match state of nodes that allow no content. */
+  static readonly empty: ContentMatch;
+}
+export { content_d_exports };