@gmb/bitmark-parser-generator 4.7.0 → 4.8.0

package/dist/index.cjs

@@ -1297,6 +1297,7 @@ var propertyKeys = {
   property_reference: "@reference",
   property_refPublicationYear: "@refPublicationYear",
   property_refPublisher: "@refPublisher",
+  property_relatedBook: "@relatedBook",
   property_releaseDate: "@releaseDate",
   property_releaseKind: "@releaseKind",
   property_releaseVersion: "@releaseVersion",
@@ -1572,6 +1573,16 @@ var StringUtils = class {
     if (!str) return str;
     return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
   }
+  /**
+   * Convert a camelCase string to kebab-case.
+   *
+   * @param str the string to convert
+   * @returns the kebab-case version of the string
+   */
+  camelToKebab(str) {
+    if (!str) return str;
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+  }
 };
 var stringUtils = new StringUtils();
 
@@ -3246,6 +3257,12 @@ var GROUPS = {
         format: TagFormat.plainText,
         maxCount: Count.infinity
       },
+      {
+        key: ConfigKey.property_relatedBook,
+        description: "Books related to this book",
+        format: TagFormat.plainText,
+        maxCount: Count.infinity
+      },
       {
         key: ConfigKey.property_duration,
         description: "The duration of the book",
@@ -9130,7 +9147,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "4.7.0",
+  "version": "4.8.0",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -9874,6 +9891,8 @@ var NodeType = (0, import_superenum20.superenum)({
   referencePropertyValue: "referencePropertyValue",
   refPublicationYear: "refPublicationYear",
   refPublisher: "refPublisher",
+  relatedBook: "relatedBook",
+  relatedBookValue: "relatedBookValue",
   releaseDate: "releaseDate",
   releaseDateValue: "releaseDateValue",
   releaseKind: "releaseKind",
@@ -22402,6 +22421,12 @@ var Builder = class extends BaseBuilder {
         data.publications,
         options
       ),
+      relatedBook: this.toAstProperty(
+        bitType,
+        ConfigKey.property_relatedBook,
+        data.relatedBook,
+        options
+      ),
       author: this.toAstProperty(bitType, ConfigKey.property_author, data.author, options),
       subject: this.toAstProperty(bitType, ConfigKey.property_subject, data.subject, options),
       date: this.toAstProperty(bitType, ConfigKey.property_date, data.date, options),
@@ -35812,6 +35837,264 @@ var ConfigBuilder = class {
   build(options) {
     const opts = Object.assign({}, options);
     this.buildFlat(opts);
+    const bitConfigs = [];
+    const groupConfigs = [];
+    for (const bt of BitType.values()) {
+      const bitType = instance2.getBitType(bt);
+      const _bitConfig = BITS[bitType];
+      if (_bitConfig) {
+        _bitConfig.bitType = bitType;
+        bitConfigs.push(_bitConfig);
+      }
+    }
+    for (const [k, g] of Object.entries(GROUPS)) {
+      const g2 = g;
+      let k2 = k;
+      if (k.startsWith("group_")) k2 = k2.substring(6);
+      k2 = /*'_' +*/
+      stringUtils.camelToKebab(k2);
+      g2.key = k2;
+      groupConfigs.push(g2);
+    }
+    const outputFolder = opts.outputDir ?? "assets/config";
+    const outputFolderBits = import_node_path3.default.join(outputFolder, "bits");
+    const outputFolderGroups = import_node_path3.default.join(outputFolder, "partials");
+    import_fs_extra3.default.ensureDirSync(outputFolderBits);
+    import_fs_extra3.default.ensureDirSync(outputFolderGroups);
+    const fileWrites = [];
+    for (const b of bitConfigs) {
+      const inherits = [];
+      const tags2 = [];
+      const tagEntriesTypeOrder = [
+        BitTagConfigKeyType.tag,
+        BitTagConfigKeyType.property,
+        BitTagConfigKeyType.resource,
+        BitTagConfigKeyType.group,
+        BitTagConfigKeyType.unknown
+      ];
+      const tagEntries = Object.entries(b.tags ?? []).sort((a, b2) => {
+        const tagA = a[1];
+        const tagB = b2[1];
+        const typeA = typeFromConfigKey(tagA.key);
+        const typeB = typeFromConfigKey(tagB.key);
+        const typeOrder = tagEntriesTypeOrder.indexOf(typeA) - tagEntriesTypeOrder.indexOf(typeB);
+        return typeOrder;
+      });
+      if (b.baseBitType) inherits.push(b.baseBitType);
+      for (const [_tagKey, tag] of tagEntries) {
+        const tagName = tag.key;
+        let format = "";
+        let chain = void 0;
+        const tagType = typeFromConfigKey(tag.key);
+        if (tagType === BitTagConfigKeyType.tag) {
+          if (tagName === "%") {
+            chain = {
+              key: "%",
+              format,
+              min: tag.minCount,
+              max: tag.maxCount,
+              description: "Lead",
+              chain: {
+                key: "%",
+                format,
+                min: tag.minCount,
+                max: tag.maxCount,
+                description: "Page number",
+                chain: {
+                  key: "%",
+                  format,
+                  min: tag.minCount,
+                  max: tag.maxCount,
+                  description: "Margin number"
+                }
+              }
+            };
+          }
+          format = "bitmark--";
+        } else if (tagType === BitTagConfigKeyType.property) {
+          if (tag.format === TagFormat.plainText) {
+            format = "string";
+          } else if (tag.format === TagFormat.boolean) {
+            format = "bool";
+          } else if (tag.format === TagFormat.bitmarkText) {
+            format = "bitmark";
+          } else if (tag.format === TagFormat.number) {
+            format = "number";
+          }
+        } else if (tagType === BitTagConfigKeyType.resource) {
+        } else if (tagType === BitTagConfigKeyType.group) {
+          let k = tag.key;
+          if (k.startsWith("group_")) k = k.substring(6);
+          k = "_" + k;
+          inherits.push(k);
+          continue;
+        }
+        const t = {
+          key: tagName,
+          format,
+          default: null,
+          alwaysInclude: false,
+          min: tag.minCount == null ? 0 : tag.minCount,
+          max: tag.maxCount == null ? 1 : tag.maxCount,
+          description: tag.description ?? "",
+          chain
+          // raw: {
+          //   ...tag,
+          // },
+        };
+        tags2.push(t);
+      }
+      const bitJson = {
+        name: b.bitType,
+        description: b.description ?? "",
+        since: b.since,
+        deprecated: b.deprecated,
+        history: [
+          {
+            version: b.since,
+            changes: ["Initial version"]
+          }
+        ],
+        format: b.textFormatDefault ?? "bitmark--",
+        bodyAllowed: b.bodyAllowed ?? true,
+        bodyRequired: b.bodyRequired ?? false,
+        footerAllowed: b.footerAllowed ?? true,
+        footerRequired: b.footerRequired ?? false,
+        resourceAttachmentAllowed: b.resourceAttachmentAllowed ?? true,
+        inherits,
+        tags: tags2
+      };
+      const output = import_node_path3.default.join(outputFolderBits, `${b.bitType}.jsonc`);
+      const str = JSON.stringify(bitJson, null, 2);
+      fileWrites.push(import_fs_extra3.default.writeFile(output, str));
+    }
+    const writeGroupConfigs = (groupConfigs2) => {
+      for (const g of groupConfigs2) {
+        const inherits = [];
+        const tags2 = [];
+        const groupKey = stringUtils.camelToKebab(g.key);
+        const tagEntriesTypeOrder = [
+          BitTagConfigKeyType.tag,
+          BitTagConfigKeyType.property,
+          BitTagConfigKeyType.resource,
+          BitTagConfigKeyType.group
+        ];
+        const tagEntries = Object.entries(g.tags ?? []).sort((a, b) => {
+          const tagA = a[1];
+          const tagB = b[1];
+          const typeOrder = tagEntriesTypeOrder.indexOf(tagA.type) - tagEntriesTypeOrder.indexOf(tagB.type);
+          return typeOrder;
+        });
+        for (const [_tagKey, tag] of tagEntries) {
+          let tagName = tag.key;
+          const tagType = typeFromConfigKey(tag.key);
+          let format = "";
+          let chain = void 0;
+          if (tagType === BitTagConfigKeyType.tag) {
+            tagName = tag.name;
+            if (tagName === "%") {
+              chain = {
+                key: "%",
+                format,
+                min: tag.minCount,
+                max: tag.maxCount,
+                description: "Lead",
+                chain: {
+                  key: "%",
+                  format,
+                  min: tag.minCount,
+                  max: tag.maxCount,
+                  description: "Page number",
+                  chain: {
+                    key: "%",
+                    format,
+                    min: tag.minCount,
+                    max: tag.maxCount,
+                    description: "Margin number"
+                  }
+                }
+              };
+            }
+            format = "bitmark--";
+          } else if (tagType === BitTagConfigKeyType.property) {
+            tagName = tag.key;
+            if (tag.format === TagFormat.plainText) {
+              format = "string";
+            } else if (tag.format === TagFormat.boolean) {
+              format = "bool";
+            } else if (tag.format === TagFormat.bitmarkText) {
+              format = "bitmark";
+            } else if (tag.format === TagFormat.number) {
+              format = "number";
+            }
+          } else if (tagType === BitTagConfigKeyType.resource) {
+            format = "string";
+          } else if (tagType === BitTagConfigKeyType.group) {
+            let k = tag.key;
+            if (k.startsWith("group_")) k = k.substring(6);
+            k = /*'_' +*/
+            stringUtils.camelToKebab(k);
+            inherits.push(k);
+            continue;
+          }
+          const t = {
+            key: tagName,
+            format,
+            default: null,
+            alwaysInclude: false,
+            min: tag.minCount == null ? 0 : tag.minCount,
+            max: tag.maxCount == null ? 1 : tag.maxCount,
+            description: tag.description ?? "",
+            chain
+            // raw: {
+            //   ...tag,
+            // },
+          };
+          tags2.push(t);
+        }
+        const bitJson = {
+          name: groupKey,
+          description: g.description ?? "",
+          since: "UNKNOWN",
+          deprecated: g.deprecated,
+          history: [
+            {
+              version: "UNKNOWN",
+              changes: ["Initial version"]
+            }
+          ],
+          inherits,
+          tags: tags2
+          // cards: [
+          //   {
+          //     card: null,
+          //     side: 1,
+          //     variant: null,
+          //     description: '',
+          //     tags: [],
+          //   },
+          //   {
+          //     card: null,
+          //     side: 2,
+          //     variant: 1,
+          //     description: '',
+          //     tags: [],
+          //   },
+          //   {
+          //     card: null,
+          //     side: 2,
+          //     variant: null,
+          //     description: '',
+          //     tags: [],
+          //   },
+          // ],
+        };
+        const output = import_node_path3.default.join(outputFolderGroups, `${groupKey}.jsonc`);
+        const str = JSON.stringify(bitJson, null, 2);
+        import_fs_extra3.default.writeFileSync(output, str);
+      }
+    };
+    writeGroupConfigs(groupConfigs);
   }
   buildFlat(options) {
     const opts = Object.assign({}, options);