tabletop-commander/lib/tcmd/TokenIdentifiers.ts

export const TokenIdentifiers = new Map<string, {
  rx: RegExp;
  parse: (s: string) => Token;
}>();

// TokenIdentifiers.set("p", {
//   rx: /\n{2,}((?:.|\n)*?)\n{2,}/g,
//   parse(s) {
//     const [_, content] = s.match(new RegExp(this.rx, ""))!;

//     return {
//       // content,
//       content,
//       raw: s,
//       metadata: {},
//       type: "p",
//       uuid: crypto.randomUUID(),
//     };
//   },
// });
const rendersContentOnly = true;
const rendersChildrenOnly = true;
TokenIdentifiers.set("card", {
  rx: /\[{2}\n+([\s\S]*?)\n+\]{2}/g,
  parse(s) {
    return {
      content: s.match(new RegExp(this.rx, ""))?.at(1) ||
        "Unable to parse card",
      raw: s,
      metadata: {},
      type: "card",
      uuid: crypto.randomUUID(),
    };
  },
});
TokenIdentifiers.set("code", {
  rx: /`{3}\n+((?:.|\n)*?)\n+`{3}/g,
  parse(s) {
    return {
      content: s.match(new RegExp(this.rx, ""))?.at(1) ||
        "Unable to parse code",
      raw: s,
      metadata: {},
      type: "code",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("list", {
  rx: /^\s*-\s([\s\S]*?)\n\n/gm,
  parse(s) {
    return {
      content: s.match(new RegExp(this.rx, ""))?.at(1) ||
        "Unable to parse list",
      raw: s,
      metadata: {
        initialDepth: s.replace("\n", "").split("-").at(0)?.length.toString() ||
          "1",
      },
      type: "list",
      uuid: crypto.randomUUID(),
      rendersChildrenOnly,
    };
  },
});
TokenIdentifiers.set("list-item", {
  rx: /^\s*-\s(.*?)$/gm,
  parse(s) {
    return {
      content: s.match(new RegExp(this.rx, ""))?.at(1) ||
        "Unable to parse list-item",
      raw: s,
      metadata: {
        initialDepth: s.replace("\n", "").split("-").at(0)?.length.toString() ||
          "1",
      },
      type: "list-item",
      uuid: crypto.randomUUID(),
    };
  },
});
TokenIdentifiers.set("grid", {
  rx: /(?:\[\])+\n+((?:.|\n)*?)\n+\/\[\]/g,
  parse(s) {
    return {
      content: s.match(new RegExp(this.rx, ""))?.at(1) ||
        "Unable to parse grid",
      raw: s,
      metadata: {
        columns: s.split("\n").at(0)?.match(/\[\]/g)?.length.toString() || "1",
      },
      type: "grid",
      uuid: crypto.randomUUID(),
      rendersChildrenOnly,
    };
  },
});
TokenIdentifiers.set("heading", {
  rx: /^#+\s(.*?)$/gm,
  parse(s) {
    return {
      content: s.match(new RegExp(this.rx, ""))?.at(1) ||
        "Unable to parse heading",
      raw: s,
      metadata: {
        strength: s.match(/#/g)?.length.toString() || "1",
      },
      type: "heading",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("image", {
  rx: /\!\[(.*?)\]\((.*?)\)/g,
  parse(s) {
    const [_, title, src] = s.match(new RegExp(this.rx, ""))!;

    return {
      // content: inline,
      content: title.trim(),
      raw: s,
      metadata: {
        src,
      },
      type: "image",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("anchor", {
  rx: /(?<![\!^])\[(.*?)\]\((.*?)\)/g,
  parse(s) {
    let preset, [_, title, href] = s.match(new RegExp(this.rx, ""))!;
    const match = title.match(/`{3}(cta|button)?(.*)/);

    if (match) {
      [_, preset, title] = match;
    }

    const classes = {
      button: "btn-primary inline-block",
      cta: "btn-secondary inline-block uppercase",
    };
    return {
      // content: inline,
      content: title.trim(),
      raw: s,
      metadata: {
        href,
        classes: classes[preset as keyof typeof classes],
      },
      type: "anchor",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("inline-code", {
  rx: /\s?`(.{3,}|[a-z0-9]*?)`[^`a-z0-9\n]/gi,
  parse(s) {
    return {
      // content: inline,
      content: s.match(new RegExp(this.rx, "i"))?.at(1) ||
        "Unable to parse inline-code",
      raw: s,
      metadata: {},
      type: "inline-code",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("bold", {
  rx: /\*{2}(.*?)\*{2}/g,
  parse(s) {
    return {
      // content: inline,
      content: s.match(new RegExp(this.rx, "i"))?.at(1) ||
        "Unable to parse bold",
      raw: s,
      metadata: {},
      type: "bold",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("italic", {
  rx: /(?<!\*)\*([^\*]+?)\*(?!\*)/g,
  parse(s) {
    return {
      // content: inline,
      content: s.match(new RegExp(this.rx, "i"))?.at(1) ||
        "Unable to parse italic",
      raw: s,
      metadata: {},
      type: "italic",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("popover", {
  rx: /\^\[(.*?)\]\<<(.*?)\>>/g,
  parse(s) {
    const [_, title, content] = s.match(new RegExp(this.rx, ""))!;

    return {
      // content,
      content,
      raw: s,
      metadata: { title },
      type: "popover",
      uuid: crypto.randomUUID(),
      rendersContentOnly,
    };
  },
});
TokenIdentifiers.set("accordion", {
  rx: /\[accordion(\s.*?)?]\n+((?:.|\n)*?)\n+\[\/accordion\]/g,
  parse(s) {
    const [_, title, content] = s.match(new RegExp(this.rx, ""))!;

    return {
      // content,
      content,
      raw: s,
      metadata: { title },
      type: "accordion",
      uuid: crypto.randomUUID(),
    };
  },
});
TokenIdentifiers.set("p", {
  // rx: /(?<=\n)\n?([\s\S]*?)\n(?=\n)/g,
  rx: /(?<=\n\n)([\s\S]*?)(?=\n\n)/g,
  parse(s) {
    // const [_, content] = s.match(new RegExp(this.rx, ""))!;

    return {
      // content,
      content: s,
      raw: s,
      metadata: {},
      type: "p",
      uuid: crypto.randomUUID(),
    };
  },
});

// const p = TokenIdentifiers.get("p");
// TokenIdentifiers.clear();
// p && TokenIdentifiers.set("p", p);