createSerializer.js

type LexicalNodeType2<Type> = $ReadOnly<{
  type: Type,
  ...
}>;

export type SerializedXNode = $ReadOnly<{
  // children: Array<SerializedNode>,
  direction: 'ltr' | 'rtl' | null,
  format: number,
  indent: number,
  type: 'x',
}>;

export type SerializedYNode = $ReadOnly<{
  // children: Array<SerializedNode>,
  z: number,
  format: number,
  indent: number,
  type: 'y',
}>;

export type XYNodes = SerializedXNode | SerializedYNode;

export function $serializeXNode(node: LexicalNode): SerializedXNode {
  // const latest = node.getLatest();
  // return {
  //   content: node.getTextContent(),
  //   detail: latest.__detail,
  //   format: node.getFormat(),
  //   mode: latest.__mode,
  //   style: node.getStyle(),
  //   type: 'text',
  // };
}

export function $deserializeXNode(json: SerializedXNode<'x'>): LexicalNode {
  // const textNode = $createTextNode(json.content);
  // textNode.setFormat(json.format);
  // textNode.setStyle(json.style);
  // textNode.__mode = json.mode;
  // textNode.__detail = json.detail;
  // return textNode;
}

class Serializer<K> {
  // : LexicalNodeType2<Type>
  add<Type: string, TheSerializedNode: SerializedXNode>(
    type: Type,
    serializeFn: (node: LexicalNode) => TheSerializedNode,
    deserializeFn: (json: TheSerializedNode) => null | LexicalNode,
    zz: (K) => null | SerializedXNode,
  ) {}
}

class Foo2Serializer extends Serializer<XYNodes> {}

new Foo2Serializer().add<'x', SerializedXNode>(
  'x',
  (node) => {
    if (!$isTextNode(node)) {
      throw new Error('bad');
    }
    return $serializeXNode(node);
  },
  (json): null | LexicalNode => {
    return $deserializeXNode(json);
  },
  (serializedNode: XYNodes): null | SerializedXNode => {
    if (serializedNode.type === 'x') {
      return serializedNode;
    } else {
      return null;
    }
  },
);