@bright.global/arboretum-sdk 0.0.6

package/dist/impl/data/helpers/entry-status.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entryStatus = void 0;
+// https://www.contentful.com/developers/docs/tutorials/general/determine-entry-asset-state/
+var entryStatus = function (sys) {
+    if (!sys) {
+        return;
+    }
+    else if (!!sys.publishedVersion && sys.version === sys.publishedVersion + 1)
+        return "published";
+    else if (!sys.publishedVersion)
+        return "draft";
+    else if (!!sys.publishedVersion &&
+        sys.version &&
+        sys.version >= sys.publishedVersion + 2)
+        return "changed";
+    else if (!!sys.archivedVersion)
+        return "archived";
+    else {
+        return;
+    }
+};
+exports.entryStatus = entryStatus;

package/dist/impl/data/helpers/get-all-entries-recursively.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllEntriesRecursively = void 0;
+/*
+  Even if you define flag "include: 0" in contentful client the references (at least some of them) are resolved.
+  This results in a large amount of data being stored in memory unnecessarily.
+  The purpose of this function is to filter out all redundant data and keep the references (sys field) only.
+*/
+var filterOutNestedEntriesFieldsOtherThanSysEff = function (entry) {
+    return function (field) {
+        Object.keys(entry.fields[field] || {}).forEach(function (localeCode) {
+            var nestedEntry = entry.fields[field][localeCode];
+            if (Array.isArray(nestedEntry)) {
+                nestedEntry.forEach(function (e, idx) {
+                    nestedEntry[idx] = { sys: e === null || e === void 0 ? void 0 : e.sys };
+                });
+            }
+            else {
+                nestedEntry = { sys: nestedEntry === null || nestedEntry === void 0 ? void 0 : nestedEntry.sys };
+            }
+        });
+        return entry;
+    };
+};
+var getAllEntriesRecursively = function (_a, contentType, skip, acc, select, refFieldsToFilterOut, limit) {
+    var getEntries = _a.getEntries;
+    if (refFieldsToFilterOut === void 0) { refFieldsToFilterOut = []; }
+    if (limit === void 0) { limit = 1000; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var items;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, getEntries({
+                        limit: limit,
+                        skip: skip,
+                        content_type: contentType,
+                        include: 0,
+                        select: select,
+                        locale: "*",
+                    })];
+                case 1:
+                    items = (_b.sent()).items;
+                    items.forEach(function (i) {
+                        refFieldsToFilterOut.forEach(function (field) {
+                            filterOutNestedEntriesFieldsOtherThanSysEff(i)(field);
+                        });
+                    });
+                    acc.push.apply(acc, __spreadArray([], __read(items), false));
+                    return [2 /*return*/, items.length >= limit
+                            ? (0, exports.getAllEntriesRecursively)({ getEntries: getEntries }, contentType, skip + limit, acc, select)
+                            : acc];
+            }
+        });
+    });
+};
+exports.getAllEntriesRecursively = getAllEntriesRecursively;

package/dist/impl/data/helpers/get-all-entries-recursively.test.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var get_all_entries_recursively_1 = require("./get-all-entries-recursively");
+var mocked_contentful_entries_client_api_1 = require("./__mocks__/mocked-contentful-entries-client-api");
+var testContentTypeId = "test";
+describe(get_all_entries_recursively_1.getAllEntriesRecursively, function () {
+    test("Handle case where there are no entries", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entries;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, get_all_entries_recursively_1.getAllEntriesRecursively)((0, mocked_contentful_entries_client_api_1.mockedContentfulEntriesClientApi)(testContentTypeId, 0), testContentTypeId, 0, [], undefined, [], 10)];
+                case 1:
+                    entries = _a.sent();
+                    expect(entries.length).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test("Handle case where entries can be fetched with single request ", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var total, entries, entriesIds, expectedEntriesIds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    total = 10;
+                    return [4 /*yield*/, (0, get_all_entries_recursively_1.getAllEntriesRecursively)((0, mocked_contentful_entries_client_api_1.mockedContentfulEntriesClientApi)(testContentTypeId, total), testContentTypeId, 0, [], undefined, [], 10)];
+                case 1:
+                    entries = _a.sent();
+                    entriesIds = entries.map(function (e) { return e.sys.id; });
+                    expectedEntriesIds = __spreadArray([], __read(Array(total).keys()), false).map(function (_, idx) {
+                        return (0, mocked_contentful_entries_client_api_1.mockedEntrySysId)(testContentTypeId, idx);
+                    });
+                    expect(entriesIds).toEqual(expectedEntriesIds);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test("Handle case where entries must be fetched with multiple requests ", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var total, entries, entriesIds, expectedEntriesIds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    total = 101;
+                    return [4 /*yield*/, (0, get_all_entries_recursively_1.getAllEntriesRecursively)((0, mocked_contentful_entries_client_api_1.mockedContentfulEntriesClientApi)(testContentTypeId, total), testContentTypeId, 0, [], undefined, [], 10)];
+                case 1:
+                    entries = _a.sent();
+                    entriesIds = entries.map(function (e) { return e.sys.id; });
+                    expectedEntriesIds = __spreadArray([], __read(Array(total).keys()), false).map(function (_, idx) {
+                        return (0, mocked_contentful_entries_client_api_1.mockedEntrySysId)(testContentTypeId, idx);
+                    });
+                    expect(entriesIds).toEqual(expectedEntriesIds);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/dist/impl/data/helpers/home-pages-by-tag-id.js

@@ -0,0 +1,70 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.homePagesByTagId = void 0;
+var locale_codes_from_metadata_1 = require("./locale-codes-from-metadata");
+var homePagesByTagId = function (ctx, locales, entries) {
+    var seed = { homePagesByTagId: new Map() };
+    return entries
+        .filter(function (entry) { var _a; return !!((_a = entry.metadata) === null || _a === void 0 ? void 0 : _a.tags.find(function (t) { return t.sys.id === ctx.pageHomeTagId; })); })
+        .reduce(function (acc, entry) {
+        var entryRef = { sys: { id: entry.sys.id } };
+        /*
+          Currently we don't support contentful locales fallback mechanism in tags.
+          It means that if you want to customize home pages per locale you should add
+          locale tag for every locale
+        */
+        var tagBasedLocaleCodes = (0, locale_codes_from_metadata_1.localeCodesFromMetadata)(ctx.localeTagIdPrefix, entry.metadata).filter(function (code) { return !!locales.locales.get(code); });
+        var localeCodes = tagBasedLocaleCodes.length > 0
+            ? tagBasedLocaleCodes
+            : __spreadArray([], __read(locales.locales.keys()), false);
+        localeCodes.forEach(function (localeCode) {
+            var localizedPagesByTagId = acc.homePagesByTagId.get(localeCode);
+            if (localizedPagesByTagId) {
+                var localizedPages = localizedPagesByTagId.get(ctx.pageHomeTagId);
+                if (localizedPages) {
+                    var warning = "More than one page is tagged as home page (tagLocaleCode: ".concat(localeCode, ", entryId: ").concat(entry.sys.id, ")");
+                    localizedPages.push(entryRef);
+                    localizedPagesByTagId.set(ctx.pageHomeTagId, localizedPages);
+                    if (acc.warnings)
+                        acc.warnings.push(warning);
+                    else {
+                        acc.warnings = [warning];
+                    }
+                }
+                else {
+                    localizedPagesByTagId.set(ctx.pageHomeTagId, [entryRef]);
+                }
+            }
+            else {
+                acc.homePagesByTagId.set(localeCode, new Map([[ctx.pageHomeTagId, [entryRef]]]));
+            }
+        });
+        return acc;
+    }, seed);
+};
+exports.homePagesByTagId = homePagesByTagId;

package/dist/impl/data/helpers/home-pages-by-tag-id.test.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var json_stringify_map_replacer_1 = require("../../../utils/json-stringify-map-replacer");
+var home_pages_by_tag_id_1 = require("./home-pages-by-tag-id");
+var ctx = {
+    localeTagIdPrefix: 'locale',
+    pageHomeTagId: 'pageHome',
+};
+var locales = {
+    defaultLocaleCode: 'en',
+    locales: new Map([
+        ['en', { code: 'en', default: true, fallbackCode: null, name: 'English' }],
+        ['de', { code: 'de', default: false, fallbackCode: null, name: 'German' }],
+        [
+            'en-AT',
+            { code: 'en-AT', default: false, fallbackCode: 'en', name: 'English' },
+        ],
+    ]),
+};
+var emptyHomePagesByTagId = {
+    homePagesByTagId: new Map(),
+};
+describe(home_pages_by_tag_id_1.homePagesByTagId, function () {
+    test('Home pages of empty entries', function () {
+        expect((0, home_pages_by_tag_id_1.homePagesByTagId)(ctx, locales, [])).toMatchObject(emptyHomePagesByTagId);
+    });
+    test('Home pages of entries without metadata', function () {
+        var entries = [
+            { sys: { id: 'test1' }, metadata: undefined },
+            { sys: { id: 'test2' }, metadata: undefined },
+        ];
+        expect((0, home_pages_by_tag_id_1.homePagesByTagId)(ctx, locales, entries)).toMatchObject(emptyHomePagesByTagId);
+    });
+    test('Home pages of entries with home page metadata', function () {
+        var test1SysId = 'test1';
+        var entries = [
+            {
+                sys: { id: test1SysId },
+                metadata: { tags: [{ sys: { id: ctx.pageHomeTagId } }] },
+            },
+            {
+                sys: { id: 'test2' },
+                metadata: { tags: [{ sys: { id: 'someOtherTag' } }] },
+            },
+        ];
+        var r = {
+            homePagesByTagId: new Map([
+                ['en', new Map([[ctx.pageHomeTagId, [{ sys: { id: test1SysId } }]]])],
+                ['de', new Map([[ctx.pageHomeTagId, [{ sys: { id: test1SysId } }]]])],
+                [
+                    'en-AT',
+                    new Map([[ctx.pageHomeTagId, [{ sys: { id: test1SysId } }]]]),
+                ],
+            ]),
+        };
+        expect(JSON.stringify((0, home_pages_by_tag_id_1.homePagesByTagId)(ctx, locales, entries), json_stringify_map_replacer_1.jsonStrigifyMapReplacer)).toBe(JSON.stringify(r, json_stringify_map_replacer_1.jsonStrigifyMapReplacer));
+    });
+    test('Home pages of entries with home page and locales metadata', function () {
+        var test1SysId = 'test1';
+        var test3SysId = 'test3';
+        var test4SysId = 'test4';
+        var entries = [
+            {
+                sys: { id: test1SysId },
+                metadata: {
+                    tags: [
+                        { sys: { id: ctx.pageHomeTagId } },
+                        { sys: { id: "".concat(ctx.localeTagIdPrefix, "EnAt") } },
+                    ],
+                },
+            },
+            {
+                sys: { id: 'test2' },
+                metadata: { tags: [{ sys: { id: 'someOtherTag' } }] },
+            },
+            {
+                sys: { id: test3SysId },
+                metadata: {
+                    tags: [
+                        { sys: { id: ctx.pageHomeTagId } },
+                        { sys: { id: "".concat(ctx.localeTagIdPrefix, "De") } },
+                    ],
+                },
+            },
+            {
+                sys: { id: test4SysId },
+                metadata: {
+                    tags: [
+                        { sys: { id: ctx.pageHomeTagId } },
+                        { sys: { id: "".concat(ctx.localeTagIdPrefix, "En") } },
+                    ],
+                },
+            },
+        ];
+        var r = {
+            homePagesByTagId: new Map([
+                [
+                    'en-AT',
+                    new Map([[ctx.pageHomeTagId, [{ sys: { id: test1SysId } }]]]),
+                ],
+                ['de', new Map([[ctx.pageHomeTagId, [{ sys: { id: test3SysId } }]]])],
+                ['en', new Map([[ctx.pageHomeTagId, [{ sys: { id: test4SysId } }]]])],
+            ]),
+        };
+        expect(JSON.stringify((0, home_pages_by_tag_id_1.homePagesByTagId)(ctx, locales, entries), json_stringify_map_replacer_1.jsonStrigifyMapReplacer)).toBe(JSON.stringify(r, json_stringify_map_replacer_1.jsonStrigifyMapReplacer));
+    });
+});

package/dist/impl/data/helpers/locale-codes-from-metadata.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localeCodesFromMetadata = void 0;
+var parse_locale_tag_1 = require("./parse-locale-tag");
+var localeCodesFromMetadata = function (localeTagIdPrefix, metadata) {
+    return (metadata === null || metadata === void 0 ? void 0 : metadata.tags.flatMap(function (t) {
+        var maybeLocaleCode = (0, parse_locale_tag_1.parseLocaleTag)(localeTagIdPrefix)(t.sys.id);
+        return maybeLocaleCode ? [maybeLocaleCode.localeCode] : [];
+    })) || [];
+};
+exports.localeCodesFromMetadata = localeCodesFromMetadata;

package/dist/impl/data/helpers/locale-codes-from-metadata.test.js

@@ -0,0 +1,54 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var locale_codes_from_metadata_1 = require("./locale-codes-from-metadata");
+var localeTagIdPrefix = 'locale';
+var emptyMetadata = { tags: [] };
+var nonEmptyMetadata = {
+    tags: [{ sys: { id: 'someTagId' } }],
+};
+var nonEmptyMetadataWithValidLocales = {
+    tags: __spreadArray(__spreadArray([
+        { sys: { id: 'localeEn' } }
+    ], __read(nonEmptyMetadata.tags), false), [
+        { sys: { id: 'localeDe' } },
+    ], false),
+};
+describe(locale_codes_from_metadata_1.localeCodesFromMetadata, function () {
+    test('Locale codes from empty metadata', function () {
+        expect((0, locale_codes_from_metadata_1.localeCodesFromMetadata)(localeTagIdPrefix, emptyMetadata).length).toEqual(0);
+    });
+    test('Locale codes from metadata (without valid locales)', function () {
+        expect((0, locale_codes_from_metadata_1.localeCodesFromMetadata)(localeTagIdPrefix, nonEmptyMetadata).length).toEqual(0);
+    });
+    test('Locale codes from metadata (without valid locales)', function () {
+        expect((0, locale_codes_from_metadata_1.localeCodesFromMetadata)(localeTagIdPrefix, nonEmptyMetadata).length).toEqual(0);
+    });
+    test('Locale codes from metadata (with valid locales)', function () {
+        expect((0, locale_codes_from_metadata_1.localeCodesFromMetadata)(localeTagIdPrefix, nonEmptyMetadataWithValidLocales)).toEqual(['en', 'de']);
+    });
+});

package/dist/impl/data/helpers/parse-locale-tag.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLocaleTag = void 0;
+var parseLocaleTag = function (localeTagIdPrefix) {
+    return function (tagId) {
+        if (tagId.startsWith(localeTagIdPrefix)) {
+            var codes = tagId
+                .substring(localeTagIdPrefix.length, tagId.length)
+                .split(/(?=[A-Z])/)
+                .flatMap(function (code) { return (code ? [code] : []); });
+            if (codes.length === 1) {
+                return { localeCode: codes[0].toLowerCase() };
+            }
+            else if (codes.length === 2) {
+                return {
+                    localeCode: "".concat(codes[0].toLowerCase(), "-").concat(codes[1].toUpperCase()),
+                };
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    };
+};
+exports.parseLocaleTag = parseLocaleTag;

package/dist/impl/data/helpers/parse-locale-tag.test.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var parse_locale_tag_1 = require("./parse-locale-tag");
+var localeTagIdPrefix = 'locale';
+var parseTag = (0, parse_locale_tag_1.parseLocaleTag)(localeTagIdPrefix);
+describe(parse_locale_tag_1.parseLocaleTag, function () {
+    test('Invalid locale tag is handled properly', function () {
+        var _a, _b, _c;
+        expect((_a = parseTag('locale')) === null || _a === void 0 ? void 0 : _a.localeCode).toBeUndefined();
+        expect((_b = parseTag('test')) === null || _b === void 0 ? void 0 : _b.localeCode).toBeUndefined();
+        expect((_c = parseTag('localeEnAtEn')) === null || _c === void 0 ? void 0 : _c.localeCode).toBeUndefined();
+    });
+    test('Locale country tag is parsed properly', function () {
+        var _a;
+        expect((_a = parseTag('localeEn')) === null || _a === void 0 ? void 0 : _a.localeCode).toBe('en');
+    });
+    test('Locale language-country tag is parsed properly', function () {
+        var _a;
+        expect((_a = parseTag('localeEnAt')) === null || _a === void 0 ? void 0 : _a.localeCode).toBe('en-AT');
+    });
+});