@bright.global/arboretum-sdk 0.0.6

package/dist/es6/impl/data/helpers/__mocks__/mocked-contentful-entries-client-api.js

@@ -0,0 +1,66 @@
+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));
+};
+var defaultLimit = 100;
+var defaultSkip = 0;
+export var mockedEntrySysId = function (contentType, idx) {
+    return "".concat(contentType).concat(idx);
+};
+export var mockedContentfulEntriesClientApi = function (contentType, total) { return ({
+    getEntries: function (query) {
+        var limit = typeof (query === null || query === void 0 ? void 0 : query.limit) !== 'undefined' ? query.limit : defaultLimit;
+        var skip = typeof (query === null || query === void 0 ? void 0 : query.skip) !== 'undefined' ? query.skip : defaultSkip;
+        var remaining = total - skip;
+        var contentTypeId = (query === null || query === void 0 ? void 0 : query.content_type) || contentType;
+        var items = __spreadArray([], __read(Array(remaining >= limit ? limit : remaining).keys()), false).map(function (_, idx) { return ({
+            sys: {
+                id: mockedEntrySysId(contentTypeId, skip + idx),
+                contentType: {
+                    sys: { id: contentTypeId },
+                },
+            },
+            fields: [],
+        }); });
+        return Promise.resolve({
+            items: items,
+            limit: limit,
+            skip: skip,
+            total: total,
+        });
+    },
+}); };
+export var multipleContentTypesMockedContentfulEntriesClientApi = function (contentTypes) { return ({
+    getEntries: function (query) {
+        var contentType = contentTypes.find(function (ct) { return ct.contentType === (query === null || query === void 0 ? void 0 : query.content_type); });
+        return contentType
+            ? mockedContentfulEntriesClientApi(contentType.contentType, contentType.total).getEntries(query)
+            : Promise.resolve({
+                items: [],
+                limit: (query === null || query === void 0 ? void 0 : query.limit) || defaultLimit,
+                skip: (query === null || query === void 0 ? void 0 : query.skip) || defaultSkip,
+                total: 0,
+            });
+    },
+}); };

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

@@ -0,0 +1,19 @@
+// https://www.contentful.com/developers/docs/tutorials/general/determine-entry-asset-state/
+export 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;
+    }
+};

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

@@ -0,0 +1,113 @@
+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));
+};
+/*
+  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;
+    };
+};
+export 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
+                            ? getAllEntriesRecursively({ getEntries: getEntries }, contentType, skip + limit, acc, select)
+                            : acc];
+            }
+        });
+    });
+};

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

@@ -0,0 +1,114 @@
+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));
+};
+import { getAllEntriesRecursively } from "./get-all-entries-recursively";
+import { mockedContentfulEntriesClientApi, mockedEntrySysId, } from "./__mocks__/mocked-contentful-entries-client-api";
+var testContentTypeId = "test";
+describe(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*/, getAllEntriesRecursively(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*/, getAllEntriesRecursively(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 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*/, getAllEntriesRecursively(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 mockedEntrySysId(testContentTypeId, idx);
+                    });
+                    expect(entriesIds).toEqual(expectedEntriesIds);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

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

@@ -0,0 +1,66 @@
+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));
+};
+import { localeCodesFromMetadata } from './locale-codes-from-metadata';
+export 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 = 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);
+};

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

@@ -0,0 +1,105 @@
+import { jsonStrigifyMapReplacer } from '../../../utils/json-stringify-map-replacer';
+import { homePagesByTagId } from './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(homePagesByTagId, function () {
+    test('Home pages of empty entries', function () {
+        expect(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(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(homePagesByTagId(ctx, locales, entries), jsonStrigifyMapReplacer)).toBe(JSON.stringify(r, 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(homePagesByTagId(ctx, locales, entries), jsonStrigifyMapReplacer)).toBe(JSON.stringify(r, jsonStrigifyMapReplacer));
+    });
+});

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

@@ -0,0 +1,7 @@
+import { parseLocaleTag } from './parse-locale-tag';
+export var localeCodesFromMetadata = function (localeTagIdPrefix, metadata) {
+    return (metadata === null || metadata === void 0 ? void 0 : metadata.tags.flatMap(function (t) {
+        var maybeLocaleCode = parseLocaleTag(localeTagIdPrefix)(t.sys.id);
+        return maybeLocaleCode ? [maybeLocaleCode.localeCode] : [];
+    })) || [];
+};

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

@@ -0,0 +1,52 @@
+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));
+};
+import { localeCodesFromMetadata } from './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(localeCodesFromMetadata, function () {
+    test('Locale codes from empty metadata', function () {
+        expect(localeCodesFromMetadata(localeTagIdPrefix, emptyMetadata).length).toEqual(0);
+    });
+    test('Locale codes from metadata (without valid locales)', function () {
+        expect(localeCodesFromMetadata(localeTagIdPrefix, nonEmptyMetadata).length).toEqual(0);
+    });
+    test('Locale codes from metadata (without valid locales)', function () {
+        expect(localeCodesFromMetadata(localeTagIdPrefix, nonEmptyMetadata).length).toEqual(0);
+    });
+    test('Locale codes from metadata (with valid locales)', function () {
+        expect(localeCodesFromMetadata(localeTagIdPrefix, nonEmptyMetadataWithValidLocales)).toEqual(['en', 'de']);
+    });
+});

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

@@ -0,0 +1,24 @@
+export 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;
+        }
+    };
+};

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

@@ -0,0 +1,19 @@
+import { parseLocaleTag } from './parse-locale-tag';
+var localeTagIdPrefix = 'locale';
+var parseTag = parseLocaleTag(localeTagIdPrefix);
+describe(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');
+    });
+});