@gmb/bitmark-parser-generator 5.4.0 → 5.5.0

package/dist/cli/main.js

@@ -428,6 +428,7 @@ var BitType = {
   pageHero: "page-hero",
   pageOpenBook: "page-open-book",
   pageOpenBookList: "page-open-book-list",
+  printBook: "print-book",
   openBookChapter: "open-book-chapter",
   pagePerson: "page-person",
   pageProduct: "page-product",
@@ -1206,6 +1207,7 @@ var propertyKeys = {
   property_internalPrintPdf: "@internalPrintPdf",
   property_hasPrintRestriction: "@hasPrintRestriction",
   property_enforceUpdateOverUserInput: "@enforceUpdateOverUserInput",
+  property_extractorExtractionTimestamp: "@extractorExtractionTimestamp",
   property_isCaseSensitive: "@isCaseSensitive",
   property_isInfoOnly: "@isInfoOnly",
   property_isPublic: "@isPublic",
@@ -1243,6 +1245,7 @@ var propertyKeys = {
   property_mute: "@mute",
   property_padletId: "@padletId",
   property_page: "@page",
+  property_printParentChapterLevel: "@printParentChapterLevel",
   property_pageNo: "@pageNo",
   property_partialAnswer: "@partialAnswer",
   property_partner: "@partner",
@@ -3373,6 +3376,12 @@ var GROUPS = {
         description: "If true, prioritize new content over legacy content from the instance API",
         format: TagFormat.boolean,
         defaultValue: "false"
+      },
+      {
+        key: ConfigKey.property_extractorExtractionTimestamp,
+        description: "Extraction timestamps for book conversion",
+        format: TagFormat.plainText,
+        maxCount: Count.infinity
       }
     ]
   },
@@ -6769,6 +6778,12 @@ var BITS = {
         key: ConfigKey.property_buttonCaption,
         description: "The caption of the print button",
         format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.property_printParentChapterLevel,
+        description: "The parent chapter level to print",
+        format: TagFormat.number,
+        defaultValue: "-1"
       }
     ]
   },
@@ -7349,6 +7364,39 @@ var BITS = {
       }
     ]
   },
+  [BitType.printBook]: {
+    since: "5.5.0",
+    baseBitType: BitType.article,
+    description: "Print book bit, used to create pages that open books without author information in articles or books",
+    tags: [
+      {
+        key: ConfigKey.property_slug,
+        description: "Slug for the book, used to identify the book in the system",
+        format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.property_book,
+        description: "Book reference for the page, used to link to a specific book",
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_reference,
+            description: "Reference tag for the book, used to link to the book in the system",
+            maxCount: 2
+          }
+        ]
+      },
+      {
+        /* Allow incorrectly chained reference tag */
+        key: ConfigKey.tag_reference,
+        description: "Reference tag for the book, used to link to the book in the system"
+      },
+      {
+        key: ConfigKey.property_buttonCaption,
+        description: "Caption for the button, used to define the text displayed on the button"
+      }
+    ]
+  },
   [BitType.openBookChapter]: {
     since: "4.16.0",
     baseBitType: BitType.pageOpenBook,
@@ -10244,7 +10292,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "license": "ISC"};
 var Environment = {
   unknown: "",
@@ -10835,6 +10883,8 @@ var NodeType = {
   hasPrintRestrictionValue: "hasPrintRestrictionValue",
   enforceUpdateOverUserInput: "enforceUpdateOverUserInput",
   enforceUpdateOverUserInputValue: "enforceUpdateOverUserInputValue",
+  extractorExtractionTimestamp: "extractorExtractionTimestamp",
+  extractorExtractionTimestampValue: "extractorExtractionTimestampValue",
   isCaseSensitive: "isCaseSensitive",
   isCommented: "isCommented",
   isCorrect: "isCorrect",
@@ -10938,6 +10988,8 @@ var NodeType = {
   pageNumber: "pageNumber",
   pageNumberValue: "pageNumberValue",
   pageValue: "pageValue",
+  printParentChapterLevel: "printParentChapterLevel",
+  printParentChapterLevelValue: "printParentChapterLevelValue",
   pairs: "pairs",
   pairsValue: "pairsValue",
   parent: "parent",
@@ -24533,6 +24585,12 @@ var Builder = class extends BaseBuilder {
         data.enforceUpdateOverUserInput,
         options
       ),
+      extractorExtractionTimestamp: this.toAstProperty(
+        bitType,
+        ConfigKey.property_extractorExtractionTimestamp,
+        data.extractorExtractionTimestamp,
+        options
+      ),
       tocResource: this.toAstProperty(
         bitType,
         ConfigKey.property_tocResource,
@@ -24546,6 +24604,12 @@ var Builder = class extends BaseBuilder {
         options
       ),
       page: this.toAstProperty(bitType, ConfigKey.property_page, data.page, options),
+      printParentChapterLevel: this.toAstProperty(
+        bitType,
+        ConfigKey.property_printParentChapterLevel,
+        data.printParentChapterLevel,
+        options
+      ),
       platformBrandTarget: this.toAstProperty(
         bitType,
         ConfigKey.property_platformBrandTarget,
@@ -30191,6 +30255,7 @@ var JsonGenerator = class extends AstWalkerGenerator {
         BitType.pageFooter,
         BitType.pageOpenBook,
         BitType.pagePerson,
+        BitType.printBook,
         BitType.pageProduct,
         BitType.pageProductList,
         BitType.pageProductVideo,
@@ -30211,6 +30276,9 @@ var JsonGenerator = class extends AstWalkerGenerator {
       if (instance2.isOfBitType(bitType, BitType.tocContent)) {
         if (bitJson.tocContent == null) bitJson.tocContent = [];
       }
+      if (instance2.isOfBitType(bitType, BitType.printThisChapter)) {
+        if (bitJson.printParentChapterLevel == null) bitJson.printParentChapterLevel = -1;
+      }
       if (instance2.isOfBitType(bitType, BitType.book)) {
         if (bitJson.maxTocChapterLevel == null) bitJson.maxTocChapterLevel = -1;
         if (bitJson.hasPrintRestriction == null) bitJson.hasPrintRestriction = true;
@@ -38514,6 +38582,7 @@ var JsonFileGenerator = class {
     this.generator.generateSync(_ast);
   }
 };
+var normalizeCardKey = (cardSetKey) => stringUtils.camelToKebab(cardSetKey);
 var ConfigBuilder = class {
   build(options) {
     const opts = Object.assign({}, options);
@@ -38554,8 +38623,10 @@ var ConfigBuilder = class {
     const outputFolder = opts.outputDir ?? "assets/config";
     const outputFolderBits = path3.join(outputFolder, "bits");
     const outputFolderGroups = path3.join(outputFolder, "partials");
+    const outputFolderCards = path3.join(outputFolder, "cards");
     fs3.ensureDirSync(outputFolderBits);
     fs3.ensureDirSync(outputFolderGroups);
+    fs3.ensureDirSync(outputFolderCards);
     const bitsFiles = fs3.readdirSync(outputFolderBits).filter((f) => f.endsWith(".jsonc"));
     for (const file of bitsFiles) {
       fs3.removeSync(path3.join(outputFolderBits, file));
@@ -38564,7 +38635,18 @@ var ConfigBuilder = class {
     for (const file of partialsFiles) {
       fs3.removeSync(path3.join(outputFolderGroups, file));
     }
+    const cardsFiles = fs3.readdirSync(outputFolderCards).filter((f) => f.endsWith(".jsonc"));
+    for (const file of cardsFiles) {
+      fs3.removeSync(path3.join(outputFolderCards, file));
+    }
     const fileWrites = [];
+    const tagEntriesTypeOrder = [
+      BitTagConfigKeyType.tag,
+      BitTagConfigKeyType.property,
+      BitTagConfigKeyType.resource,
+      BitTagConfigKeyType.group,
+      BitTagConfigKeyType.unknown
+    ];
     const resolveGroupReferences = (groupKey) => {
       if (squashedGroups.has(groupKey)) {
         const replacements = squashedGroups.get(groupKey);
@@ -38669,6 +38751,38 @@ var ConfigBuilder = class {
       tags2.push(t);
       return tags2;
     };
+    const serializeCardSet = (cardSetKey) => {
+      const cardSetConfig = CARDSETS[cardSetKey];
+      if (!cardSetConfig) return void 0;
+      const normalizedKey = normalizeCardKey(cardSetKey);
+      const sides = cardSetConfig.variants.map((variantList) => {
+        const variants = variantList.map((variant) => {
+          const variantTags = [];
+          const variantTagEntries = Object.entries(variant.tags ?? []).sort((a, b) => {
+            const tagA = a[1];
+            const tagB = b[1];
+            const typeA = typeFromConfigKey(tagA.key);
+            const typeB = typeFromConfigKey(tagB.key);
+            const typeOrder = tagEntriesTypeOrder.indexOf(typeA) - tagEntriesTypeOrder.indexOf(typeB);
+            return typeOrder;
+          });
+          for (const [, variantTag] of variantTagEntries) {
+            variantTags.push(...processTagEntries(variantTag, []));
+          }
+          return {
+            tags: variantTags,
+            repeatCount: variant.repeatCount ?? 1,
+            bodyAllowed: variant.bodyAllowed ?? true,
+            bodyRequired: variant.bodyRequired ?? false
+          };
+        });
+        return { variants };
+      });
+      return {
+        key: normalizedKey,
+        sides
+      };
+    };
     for (const bt of bitGroupConfigKeys) {
       const bitType = instance2.getBitType(bt);
       const _bitConfig = BITS[bitType];
@@ -38701,13 +38815,6 @@ var ConfigBuilder = class {
     for (const b of bitConfigs) {
       const resolvedBitConfig = instance2.getBitConfig(b.bitType);
       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];
@@ -38739,6 +38846,10 @@ var ConfigBuilder = class {
           tags2.push(...processTagEntries(tag, []));
         }
       }
+      let cardRef;
+      if (b.cardSet && CARDSETS[b.cardSet]) {
+        cardRef = normalizeCardKey(b.cardSet);
+      }
       const bitJson = {
         name: b.bitType,
         description: b.description ?? "",
@@ -38756,7 +38867,8 @@ var ConfigBuilder = class {
         footerAllowed: resolvedBitConfig.footerAllowed ?? true,
         footerRequired: resolvedBitConfig.footerRequired ?? false,
         resourceAttachmentAllowed: resolvedBitConfig.resourceAttachmentAllowed ?? true,
-        tags: tags2
+        tags: tags2,
+        ...cardRef ? { card: cardRef } : {}
       };
       const output = path3.join(outputFolderBits, `${b.bitType}.jsonc`);
       const str = JSON.stringify(bitJson, null, 2);
@@ -38766,7 +38878,7 @@ var ConfigBuilder = class {
       for (const g of groupConfigs2) {
         const tags2 = [];
         const groupKey = stringUtils.camelToKebab(g.key);
-        const tagEntriesTypeOrder = [
+        const tagEntriesTypeOrder2 = [
           BitTagConfigKeyType.tag,
           BitTagConfigKeyType.property,
           BitTagConfigKeyType.resource,
@@ -38775,7 +38887,7 @@ var ConfigBuilder = class {
         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);
+          const typeOrder = tagEntriesTypeOrder2.indexOf(tagA.type) - tagEntriesTypeOrder2.indexOf(tagB.type);
           return typeOrder;
         });
         for (const [_tagKey, tag] of tagEntries) {
@@ -38823,6 +38935,15 @@ var ConfigBuilder = class {
       }
     };
     writeGroupConfigs(groupConfigs);
+    const writeCardConfigs = () => {
+      for (const cardSetKey of Object.keys(CARDSETS)) {
+        const cardJson = serializeCardSet(cardSetKey);
+        if (!cardJson) continue;
+        const output = path3.join(outputFolderCards, `${cardJson.key}.jsonc`);
+        const str = JSON.stringify(cardJson, null, 2);
+        fileWrites.push(fs3.writeFile(output, str));
+      }
+    };
     const writeBitsAsGroupConfigs = (bitsAsGroupConfigs) => {
       for (const b of bitsAsGroupConfigs) {
         const groupKey = `group-${b.bitType}`;
@@ -38839,13 +38960,6 @@ var ConfigBuilder = class {
             });
           }
         }
-        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];
@@ -38876,6 +38990,7 @@ var ConfigBuilder = class {
       }
     };
     writeBitsAsGroupConfigs(bitGroupConfigs);
+    writeCardConfigs();
     Promise.all(fileWrites).then(() => {
       const validationErrors = this.validateConfigTree(outputFolder);
       if (validationErrors.length > 0) {
@@ -38901,6 +39016,7 @@ var ConfigBuilder = class {
     const errors = [];
     const outputFolderBits = path3.join(outputFolder, "bits");
     const outputFolderGroups = path3.join(outputFolder, "partials");
+    const outputFolderCards = path3.join(outputFolder, "cards");
     const availableGroups = /* @__PURE__ */ new Set();
     if (fs3.existsSync(outputFolderGroups)) {
       const groupFiles = fs3.readdirSync(outputFolderGroups).filter((f) => f.endsWith(".jsonc"));
@@ -38909,16 +39025,22 @@ var ConfigBuilder = class {
         availableGroups.add(groupName);
       }
     }
+    const availableCards = /* @__PURE__ */ new Set();
+    const cardFiles = fs3.existsSync(outputFolderCards) ? fs3.readdirSync(outputFolderCards).filter((f) => f.endsWith(".jsonc")) : [];
+    for (const file of cardFiles) {
+      const cardName = file.replace(".jsonc", "");
+      availableCards.add(cardName);
+    }
     const checkTags = (tags2, filePath, lineOffset) => {
       for (let i = 0; i < tags2.length; i++) {
         const tag = tags2[i];
-        if (tag.type === "group") {
+        if (tag?.type === "group" && tag.key) {
           if (!availableGroups.has(tag.key)) {
             const line = lineOffset + i + 1;
             errors.push(`Missing group reference '${tag.key}' in ${filePath}:${line}`);
           }
         }
-        if (tag.tags && Array.isArray(tag.tags)) {
+        if (Array.isArray(tag?.tags)) {
           checkTags(tag.tags, filePath, lineOffset + i + 1);
         }
       }
@@ -38933,6 +39055,27 @@ var ConfigBuilder = class {
           if (config.tags && Array.isArray(config.tags)) {
             checkTags(config.tags, `bits/${file}`, 15);
           }
+          if (typeof config.card === "string") {
+            if (!availableCards.has(config.card)) {
+              errors.push(`Missing card file '${config.card}' referenced in bits/${file}`);
+            }
+          } else if (config.card?.sides && Array.isArray(config.card.sides)) {
+            config.card.sides.forEach((side, sideIdx) => {
+              const variants = side.variants;
+              if (Array.isArray(variants)) {
+                variants.forEach((variant, variantIdx) => {
+                  const variantTags = variant.tags;
+                  if (Array.isArray(variantTags)) {
+                    checkTags(
+                      variantTags,
+                      `bits/${file} (card side ${sideIdx}, variant ${variantIdx})`,
+                      15
+                    );
+                  }
+                });
+              }
+            });
+          }
         } catch (err) {
           errors.push(`Failed to parse ${file}: ${err}`);
         }
@@ -38953,6 +39096,38 @@ var ConfigBuilder = class {
         }
       }
     }
+    if (cardFiles.length > 0) {
+      for (const file of cardFiles) {
+        const filePath = path3.join(outputFolderCards, file);
+        try {
+          const content = fs3.readFileSync(filePath, "utf-8");
+          const config = JSON.parse(content);
+          const expectedKey = file.replace(".jsonc", "");
+          if (config.key && config.key !== expectedKey) {
+            errors.push(`Card key mismatch in cards/${file}: expected '${expectedKey}'`);
+          }
+          if (Array.isArray(config.sides)) {
+            config.sides.forEach((side, sideIdx) => {
+              const variants = side.variants;
+              if (Array.isArray(variants)) {
+                variants.forEach((variant, variantIdx) => {
+                  const variantTags = variant.tags;
+                  if (Array.isArray(variantTags)) {
+                    checkTags(
+                      variantTags,
+                      `cards/${file} (side ${sideIdx}, variant ${variantIdx})`,
+                      10
+                    );
+                  }
+                });
+              }
+            });
+          }
+        } catch (err) {
+          errors.push(`Failed to parse cards/${file}: ${err}`);
+        }
+      }
+    }
     return errors;
   }
   // Build flat bit configs
@@ -39047,6 +39222,11 @@ var ConfigBuilder = class {
       for (const [_tagKey, tag] of tagEntries) {
         tags2.push(...processTagEntries(tag));
       }
+      let cardRef;
+      const cardSetKey = b.cardSet?.configKey;
+      if (cardSetKey && CARDSETS[cardSetKey]) {
+        cardRef = normalizeCardKey(cardSetKey);
+      }
       const bitJson = {
         name: b.bitType,
         description: "",
@@ -39064,7 +39244,8 @@ var ConfigBuilder = class {
         footerAllowed: b.footerAllowed ?? true,
         footerRequired: b.footerRequired ?? false,
         resourceAttachmentAllowed: b.resourceAttachmentAllowed ?? true,
-        tags: tags2
+        tags: tags2,
+        ...cardRef ? { card: cardRef } : {}
       };
       const output = path3.join(outputFolderBits, `${b.bitType}.jsonc`);
       const str = JSON.stringify(bitJson, null, 2);