@gmb/bitmark-parser-generator 1.3.0 → 1.4.0

package/dist/esm/generator/json/JsonGenerator.js

@@ -19,13 +19,15 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { Ast } from '../../ast/Ast';
+import { Config } from '../../config/Config';
 import { NodeType } from '../../model/ast/NodeType';
-import { AliasBitType, RootBitType, BitTypeUtils } from '../../model/enum/BitType';
+import { AliasBitType, RootBitType } from '../../model/enum/BitType';
 import { BitmarkVersion, DEFAULT_BITMARK_VERSION } from '../../model/enum/BitmarkVersion';
 import { BodyBitType } from '../../model/enum/BodyBitType';
 import { ExampleType } from '../../model/enum/ExampleType';
-import { PropertyKey } from '../../model/enum/PropertyKey';
-import { ResourceType } from '../../model/enum/ResourceType';
+import { PropertyAstKey } from '../../model/enum/PropertyAstKey';
+import { PropertyTag } from '../../model/enum/PropertyTag';
+import { ResourceTag } from '../../model/enum/ResourceTag';
 import { TextFormat } from '../../model/enum/TextFormat';
 import { TextParser } from '../../parser/text/TextParser';
 import { ArrayUtils } from '../../utils/ArrayUtils';
@@ -202,9 +204,9 @@ class JsonGenerator {
         // There is same logic here to select the correct default value of the example is the default is
         // required, and this is bit depenedent.
         // This is ugly, but it is even uglier if the defaults at set in the AST.
-        const meta = RootBitType.getMetadata(bit.bitType.root);
-        const hasRootExample = !!(meta === null || meta === void 0 ? void 0 : meta.rootExampleType);
-        const isBoolean = (meta === null || meta === void 0 ? void 0 : meta.rootExampleType) === ExampleType.boolean;
+        const bitConfig = Config.getBitConfig(bit.bitType);
+        const hasRootExample = !!bitConfig.rootExampleType;
+        const isBoolean = bitConfig.rootExampleType === ExampleType.boolean;
         if (hasRootExample) {
             // Calculate the value of the default example
             let defaultExample;
@@ -262,7 +264,7 @@ class JsonGenerator {
         this.addProperty(partnerJson, 'name', name !== null && name !== void 0 ? name : '', true);
         if (avatarImage) {
             const res = this.parseResourceToJson(avatarImage);
-            if (res && res.type === ResourceType.image) {
+            if (res && res.type === ResourceTag.image) {
                 partnerJson.avatarImage = res.image;
             }
         }
@@ -758,11 +760,57 @@ class JsonGenerator {
             this.bitJson.responses = responsesJson;
         }
     }
-    // bitmarkAst -> bits -> bitsValue -> resource
-    enter_resource(node, _parent, _route) {
-        const resource = node.value;
-        // This is a resource - handle it with the common code
-        this.bitJson.resource = this.parseResourceToJson(resource);
+    // bitmarkAst -> bits -> bitsValue -> resources
+    enter_resources(node, _parent, route) {
+        var _a;
+        const resources = node.value;
+        const bitType = this.getBitType(route);
+        const resourceType = this.getResourceType(route);
+        if (!resources || !bitType)
+            return;
+        let resourceJson;
+        const bitConfig = Config.getBitConfig(bitType);
+        const bitResourcesConfig = Config.getBitResourcesConfig(bitType, resourceType);
+        const comboMap = bitResourcesConfig.comboResourceTagTypesMap;
+        if (bitResourcesConfig.comboResourceTagTypesMap.size > 0) {
+            // The resource is a combo resource
+            // Extract the resource types from the combo resource
+            // NOTE: There should only ever be one combo resource per bit, but the code can handle multiple
+            // except for overwriting resourceJson
+            for (const [comboTagType, resourceTags] of comboMap.entries()) {
+                // Create the combo resource wrapper
+                const wrapper = {
+                    type: comboTagType,
+                };
+                // For each of the resources in this combo resource, find the actual resource and add it to the JSON
+                for (const rt of resourceTags) {
+                    const r = resources.find((r) => r.typeAlias === rt);
+                    // Extract everything except the type from the resource
+                    if (r) {
+                        const tagConfig = Config.getTagConfigForTag(bitConfig.tags, r.typeAlias);
+                        const key = (_a = tagConfig === null || tagConfig === void 0 ? void 0 : tagConfig.jsonKey) !== null && _a !== void 0 ? _a : r.typeAlias;
+                        const json = this.parseResourceToJson(r);
+                        if (json) {
+                            for (const [k, v] of Object.entries(json)) {
+                                if (k !== 'type') {
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    wrapper[key] = v;
+                                }
+                            }
+                        }
+                    }
+                }
+                resourceJson = wrapper;
+            }
+        }
+        else {
+            // This is a standard resource. If there is more than one resource, use the first one.
+            // There should not be more than one because of validation
+            if (resources.length >= 1) {
+                resourceJson = this.parseResourceToJson(resources[0]);
+            }
+        }
+        this.bitJson.resource = resourceJson;
     }
     //
     // Terminal nodes (leaves)
@@ -884,20 +932,22 @@ class JsonGenerator {
      */
     generatePropertyHandlers() {
         var _a;
-        for (const key of PropertyKey.values()) {
-            const validatedKey = PropertyKey.fromValue(key);
-            const meta = (_a = PropertyKey.getMetadata(validatedKey)) !== null && _a !== void 0 ? _a : {};
-            const astKey = meta.astKey ? meta.astKey : key;
-            const funcName = `enter_${astKey}`;
+        const propertiesConfig = Config.getRawPropertiesConfig();
+        for (const propertyConfig of Object.values(propertiesConfig)) {
+            const astKey = (_a = propertyConfig.astKey) !== null && _a !== void 0 ? _a : propertyConfig.tag;
             // Special cases (handled outside of the automatically generated handlers)
-            if (astKey === PropertyKey.example)
+            if (astKey === PropertyTag.example)
                 continue;
-            if (astKey === PropertyKey.imageSource)
+            if (astKey === PropertyTag.imageSource)
                 continue;
-            if (astKey === PropertyKey.partner)
+            if (astKey === PropertyTag.partner)
                 continue;
+            if (astKey === PropertyAstKey.markConfig)
+                continue;
+            const funcName = `enter_${astKey}`;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this[funcName] = (node, parent, _route) => {
+                var _a;
                 const value = node.value;
                 if (value == null)
                     return;
@@ -906,11 +956,9 @@ class JsonGenerator {
                 if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
                     return;
                 // Convert key as needed
-                let jsonKey = key;
-                if (meta.jsonKey)
-                    jsonKey = meta.jsonKey;
+                const jsonKey = (_a = propertyConfig.jsonKey) !== null && _a !== void 0 ? _a : propertyConfig.tag;
                 // Add the property
-                this.addProperty(this.bitJson, jsonKey, value, meta.isSingle);
+                this.addProperty(this.bitJson, jsonKey, value, propertyConfig.single);
             };
             // Bind this
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1018,131 +1066,106 @@ class JsonGenerator {
         // // Resource is valid, write it.
         let resourceJson;
         switch (resource.type) {
-            case ResourceType.image:
+            case ResourceTag.image:
                 resourceJson = {
-                    type: ResourceType.image,
+                    type: ResourceTag.image,
                     image: this.addImageResource(resource),
                 };
                 break;
-            case ResourceType.imageResponsive: {
-                const imageResponsiveResource = resource;
-                // Only write the resource if it has both an image and audio
-                if (imageResponsiveResource.imagePortrait.value != null &&
-                    imageResponsiveResource.imageLandscape.value != null) {
-                    resourceJson = {
-                        type: ResourceType.imageResponsive,
-                        imagePortrait: this.addImageResource(imageResponsiveResource.imagePortrait),
-                        imageLandscape: this.addImageResource(imageResponsiveResource.imageLandscape),
-                    };
-                }
-                break;
-            }
-            case ResourceType.imageLink:
+            case ResourceTag.imageLink:
                 resourceJson = {
-                    type: ResourceType.imageLink,
+                    type: ResourceTag.imageLink,
                     imageLink: this.addImageLinkResource(resource),
                 };
                 break;
-            case ResourceType.audio:
+            case ResourceTag.audio:
                 resourceJson = {
-                    type: ResourceType.audio,
+                    type: ResourceTag.audio,
                     audio: this.addAudioResource(resource),
                 };
                 break;
-            case ResourceType.audioEmbed:
+            case ResourceTag.audioEmbed:
                 resourceJson = {
-                    type: ResourceType.audioEmbed,
+                    type: ResourceTag.audioEmbed,
                     audioEmbed: this.addAudioEmbedResource(resource),
                 };
                 break;
-            case ResourceType.audioLink:
+            case ResourceTag.audioLink:
                 resourceJson = {
-                    type: ResourceType.audioLink,
+                    type: ResourceTag.audioLink,
                     audioLink: this.addAudioLinkResource(resource),
                 };
                 break;
-            case ResourceType.video:
+            case ResourceTag.video:
                 resourceJson = {
-                    type: ResourceType.video,
+                    type: ResourceTag.video,
                     video: this.addVideoResource(resource),
                 };
                 break;
-            case ResourceType.videoEmbed:
+            case ResourceTag.videoEmbed:
                 resourceJson = {
-                    type: ResourceType.videoEmbed,
+                    type: ResourceTag.videoEmbed,
                     videoEmbed: this.addVideoEmbedResource(resource),
                 };
                 resourceJson.videoEmbed = this.addVideoLinkResource(resource);
                 break;
-            case ResourceType.videoLink:
+            case ResourceTag.videoLink:
                 resourceJson = {
-                    type: ResourceType.videoLink,
+                    type: ResourceTag.videoLink,
                     videoLink: this.addVideoLinkResource(resource),
                 };
                 break;
-            case ResourceType.stillImageFilm: {
-                const stillImageFilmResource = resource;
-                // Only write the resource if it has both an image and audio
-                if (stillImageFilmResource.image.value != null && stillImageFilmResource.audio.value != null) {
-                    resourceJson = {
-                        type: ResourceType.stillImageFilm,
-                        image: this.addImageResource(stillImageFilmResource.image),
-                        audio: this.addAudioResource(stillImageFilmResource.audio),
-                    };
-                }
-                break;
-            }
-            case ResourceType.stillImageFilmEmbed:
+            case ResourceTag.stillImageFilmEmbed:
                 resourceJson = {
-                    type: ResourceType.stillImageFilmEmbed,
+                    type: ResourceTag.stillImageFilmEmbed,
                     stillImageFilmEmbed: this.addStillImageFilmEmbedResource(resource),
                 };
                 break;
-            case ResourceType.stillImageFilmLink:
+            case ResourceTag.stillImageFilmLink:
                 resourceJson = {
-                    type: ResourceType.stillImageFilmLink,
+                    type: ResourceTag.stillImageFilmLink,
                     stillImageFilmLink: this.addStillImageFilmLinkResource(resource),
                 };
                 break;
-            case ResourceType.article:
+            case ResourceTag.article:
                 resourceJson = {
-                    type: ResourceType.article,
+                    type: ResourceTag.article,
                     article: this.addArticleResource(resource),
                 };
                 break;
-            case ResourceType.document:
+            case ResourceTag.document:
                 resourceJson = {
-                    type: ResourceType.document,
+                    type: ResourceTag.document,
                     document: this.addDocumentResource(resource),
                 };
                 break;
-            case ResourceType.documentEmbed:
+            case ResourceTag.documentEmbed:
                 resourceJson = {
-                    type: ResourceType.documentEmbed,
+                    type: ResourceTag.documentEmbed,
                     documentEmbed: this.addDocumentEmbedResource(resource),
                 };
                 break;
-            case ResourceType.documentLink:
+            case ResourceTag.documentLink:
                 resourceJson = {
-                    type: ResourceType.documentLink,
+                    type: ResourceTag.documentLink,
                     documentLink: this.addDocumentLinkResource(resource),
                 };
                 break;
-            case ResourceType.documentDownload:
+            case ResourceTag.documentDownload:
                 resourceJson = {
-                    type: ResourceType.documentDownload,
+                    type: ResourceTag.documentDownload,
                     documentDownload: this.addDocumentDownloadResource(resource),
                 };
                 break;
-            case ResourceType.appLink:
+            case ResourceTag.appLink:
                 resourceJson = {
-                    type: ResourceType.appLink,
+                    type: ResourceTag.appLink,
                     appLink: this.addAppLinkResource(resource),
                 };
                 break;
-            case ResourceType.websiteLink:
+            case ResourceTag.websiteLink:
                 resourceJson = {
-                    type: ResourceType.websiteLink,
+                    type: ResourceTag.websiteLink,
                     websiteLink: this.addWebsiteLinkResource(resource),
                 };
                 break;
@@ -1156,8 +1179,8 @@ class JsonGenerator {
         if (StringUtils.isString(resource)) {
             const value = resource;
             resource = {
-                type: ResourceType.image,
-                typeAlias: ResourceType.image,
+                type: ResourceTag.image,
+                typeAlias: ResourceTag.image,
                 value,
                 format: UrlUtils.fileExtensionFromUrl(value),
                 provider: UrlUtils.domainFromUrl(value),
@@ -1190,8 +1213,8 @@ class JsonGenerator {
         if (StringUtils.isString(resource)) {
             const value = resource;
             resource = {
-                type: ResourceType.imageLink,
-                typeAlias: ResourceType.imageLink,
+                type: ResourceTag.imageLink,
+                typeAlias: ResourceTag.imageLink,
                 value,
                 format: UrlUtils.fileExtensionFromUrl(value),
                 provider: UrlUtils.domainFromUrl(value),
@@ -1619,6 +1642,21 @@ class JsonGenerator {
         }
         return undefined;
     }
+    /**
+     * Get the bit resourceType atttachment from any node
+     *
+     * @param route the route to the node
+     * @returns the bit type
+     */
+    getResourceType(route) {
+        for (const node of route) {
+            if (node.key === NodeType.bitsValue) {
+                const n = node.value;
+                return n === null || n === void 0 ? void 0 : n.resourceType;
+            }
+        }
+        return undefined;
+    }
     /**
      * Convert parse a string to TextAst if required, otherwise just return the string as is.
      * @param text
@@ -1794,7 +1832,7 @@ class JsonGenerator {
         };
         // Add the resource template if there should be a resource (indicated by resourceType) but there is none defined.
         // if (bit.resourceType && !bitJson.resource) {
-        //   const jsonKey = ResourceType.keyFromValue(bit.resourceType);
+        //   const jsonKey = ResourceTag.keyFromValue(bit.resourceType);
         //   bitJson.resource = {
         //     type: bit.resourceType,
         //   } as ResourceJson;
@@ -1811,7 +1849,7 @@ class JsonGenerator {
      * @returns
      */
     cleanAndSetDefaultsForBitJson(bitJson) {
-        const bitType = BitTypeUtils.getBitType(bitJson.type);
+        const bitType = Config.getBitType(bitJson.type);
         const plainText = this.options.textAsPlainText;
         // Clear 'item' which may be an empty string if 'lead' was set but item not
         // Only necessary because '.article' does not include a default value for 'item'