@bright.global/arboretum-sdk 0.0.6

package/dist/es6/impl/sitemap/helpers/is-root.js

@@ -0,0 +1 @@
+export var isRoot = function (page) { return !page.parent; };

package/dist/es6/impl/sitemap/helpers/localize-contentful-field.js

@@ -0,0 +1,22 @@
+var localizedValue = function (localesMap, locale, field) {
+    var maybeFieldValue = field[locale.code];
+    if (maybeFieldValue) {
+        return maybeFieldValue;
+    }
+    else {
+        var maybeFallbackLocale = locale.fallbackCode
+            ? localesMap.get(locale.fallbackCode)
+            : undefined;
+        return maybeFallbackLocale
+            ? localizedValue(localesMap, maybeFallbackLocale, field)
+            : undefined;
+    }
+};
+export var localizeField = function (_a, locale) {
+    var defaultLocaleCode = _a.defaultLocaleCode, locales = _a.locales;
+    return function (isFieldLocalized, field) {
+        return isFieldLocalized
+            ? localizedValue(locales, locale, field || {})
+            : field === null || field === void 0 ? void 0 : field[defaultLocaleCode];
+    };
+};

package/dist/es6/impl/sitemap/helpers/localize-contentful-field.test.js

@@ -0,0 +1,137 @@
+import { localizeField } from './localize-contentful-field';
+var enLocale = {
+    code: 'en',
+    default: true,
+    fallbackCode: null,
+    name: 'English',
+};
+var enAtLocale = {
+    code: 'en-At',
+    default: true,
+    fallbackCode: enLocale.code,
+    name: 'English',
+};
+var deLocale = {
+    code: 'de',
+    default: false,
+    fallbackCode: null,
+    name: 'German',
+};
+var deDeLocale = {
+    code: 'de-DE',
+    default: true,
+    fallbackCode: deLocale.code,
+    name: 'German',
+};
+var deAtLocale = {
+    code: 'de-AT',
+    default: true,
+    fallbackCode: deDeLocale.code,
+    name: 'German',
+};
+var esLocale = {
+    code: 'es',
+    default: true,
+    fallbackCode: deDeLocale.code,
+    name: 'Spanish',
+};
+var frLocale = {
+    code: 'fr',
+    default: false,
+    fallbackCode: null,
+    name: 'French',
+};
+var singleEnLocale = {
+    defaultLocaleCode: enLocale.code,
+    locales: new Map([[enLocale.code, enLocale]]),
+};
+var multipleIndependentLocales = {
+    defaultLocaleCode: enLocale.code,
+    locales: new Map([
+        [enLocale.code, enLocale],
+        [esLocale.code, esLocale],
+        [frLocale.code, frLocale],
+    ]),
+};
+var multipleLocales = {
+    defaultLocaleCode: enLocale.code,
+    locales: new Map([
+        [enLocale.code, enLocale],
+        [enAtLocale.code, enAtLocale],
+        [deLocale.code, deLocale],
+        [deDeLocale.code, deDeLocale],
+        [deAtLocale.code, deAtLocale],
+        [frLocale.code, frLocale],
+    ]),
+};
+describe(localizeField, function () {
+    test('Get value from empty field', function () {
+        var valueResult = localizeField(singleEnLocale, enLocale)(false, {});
+        expect(valueResult).toBeUndefined();
+        var valueEnResult = localizeField(singleEnLocale, enLocale)(true, {});
+        expect(valueEnResult).toBeUndefined();
+    });
+    test('Get value from not localized field', function () {
+        var _a, _b;
+        var stringValue = 'test';
+        var stringValueEnResult = localizeField(singleEnLocale, enLocale)(false, (_a = {},
+            _a[enLocale.code] = stringValue,
+            _a));
+        expect(stringValueEnResult).toEqual(stringValue);
+        var stringValueDeResult = localizeField(multipleIndependentLocales, deLocale)(false, (_b = {},
+            _b[enLocale.code] = stringValue,
+            _b));
+        expect(stringValueDeResult).toEqual(stringValue);
+    });
+    test('Localize field single locale', function () {
+        var _a, _b;
+        var stringValue = 'test';
+        var stringValueResult = localizeField(singleEnLocale, enLocale)(true, (_a = {},
+            _a[enLocale.code] = stringValue,
+            _a));
+        expect(stringValueResult).toEqual(stringValue);
+        var objectValue = { v: stringValue };
+        var objectValueResult = localizeField(singleEnLocale, enLocale)(true, (_b = {},
+            _b[enLocale.code] = objectValue,
+            _b));
+        expect(objectValueResult).toMatchObject(objectValue);
+    });
+    test('Localize field multiple indendent locales', function () {
+        var _a;
+        var enStringValue = 'enTest';
+        var esStringValue = 'esTest';
+        var frStringValue = 'frTest';
+        var field = (_a = {},
+            _a[enLocale.code] = enStringValue,
+            _a[esLocale.code] = esStringValue,
+            _a[frLocale.code] = frStringValue,
+            _a);
+        var enValueResult = localizeField(multipleIndependentLocales, enLocale)(true, field);
+        expect(enValueResult).toEqual(enStringValue);
+        var esValueResult = localizeField(multipleIndependentLocales, esLocale)(true, field);
+        expect(esValueResult).toEqual(esStringValue);
+        var frValueResult = localizeField(multipleIndependentLocales, frLocale)(true, field);
+        expect(frValueResult).toEqual(frStringValue);
+    });
+    test('Localize field multiple locales with fallbacks', function () {
+        var _a;
+        var enStringValue = 'enTest';
+        var deStringValue = 'deTest';
+        var field = (_a = {},
+            _a[enLocale.code] = enStringValue,
+            _a[deLocale.code] = deStringValue,
+            _a);
+        var enValueResult = localizeField(multipleLocales, enLocale)(true, field);
+        expect(enValueResult).toEqual(enStringValue);
+        var deValueResult = localizeField(multipleLocales, deLocale)(true, field);
+        expect(deValueResult).toEqual(deStringValue);
+        var frValueResult = localizeField(multipleLocales, frLocale)(true, field);
+        expect(frValueResult).toBeUndefined();
+        var enAtValueResult = localizeField(multipleLocales, enAtLocale)(true, field);
+        expect(enAtValueResult).toEqual(enStringValue);
+        var deDeValueResult = localizeField(multipleLocales, deDeLocale)(true, field);
+        expect(deDeValueResult).toEqual(deStringValue);
+        var deAtValueResult = localizeField(multipleLocales, deAtLocale)(true, field);
+        expect(deAtValueResult).toEqual(deStringValue);
+    });
+});

package/dist/es6/impl/sitemap/helpers/localized-pages-by-tag-id.js

@@ -0,0 +1,79 @@
+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 { localizedSitemapFromCacheOrBuildEff } from './build-localized-sitemap';
+import { right } from '../../../utils/fp-utils';
+import { parseLocaleTag } from '../../data/helpers/parse-locale-tag';
+import { groupBy } from '../../../utils/group-by';
+var tagFilterPredicate = function (localeTagIdPrefix, localeCode, metadata) {
+    return function (tagId) {
+        var maybeLocaleCodes = metadata.tags.flatMap(function (_a) {
+            var sys = _a.sys;
+            var locale = parseLocaleTag(localeTagIdPrefix)(sys.id);
+            return locale ? [locale.localeCode] : [];
+        });
+        var localesCondition = maybeLocaleCodes && maybeLocaleCodes.length > 0
+            ? !!maybeLocaleCodes.find(function (code) { return localeCode === code; })
+            : true;
+        var tagCondition = !!metadata.tags.find(function (_a) {
+            var sys = _a.sys;
+            return sys.id === tagId;
+        });
+        return localesCondition && tagCondition;
+    };
+};
+export var buildLocalizedPagesByTagId = function (ctx, locale) {
+    var sitemap = localizedSitemapFromCacheOrBuildEff(ctx, locale);
+    if (sitemap._tag === 'Right') {
+        var pages = __spreadArray([], __read(sitemap.right.sitemap.values()), false);
+        var tagFilterF_1 = function (metadata, tagId) {
+            return tagFilterPredicate(ctx.localeTagIdPrefix, locale.code, metadata)(tagId);
+        };
+        var tagIdPageRefArr = pages.flatMap(function (page) {
+            var _a;
+            return ((_a = page === null || page === void 0 ? void 0 : page.metadata) === null || _a === void 0 ? void 0 : _a.tags.flatMap(function (t) {
+                return page.metadata && tagFilterF_1(page.metadata, t.sys.id)
+                    ? [{ tagId: t.sys.id, sys: { id: page.sys.id } }]
+                    : [];
+            })) || [];
+        });
+        var pagesGroupedByTagId = right(groupBy(function (_a) {
+            var tagId = _a.tagId;
+            return tagId;
+        })(tagIdPageRefArr));
+        return pagesGroupedByTagId;
+    }
+    else {
+        return sitemap;
+    }
+};
+export var localizedPagesByTagIdFromCacheOrBuildEff = function (ctx, locale) {
+    var cachedLocalizedPagesByTagId = ctx.pagesByTagId.get(locale.code);
+    var localizedPageByTagId = cachedLocalizedPagesByTagId
+        ? cachedLocalizedPagesByTagId
+        : buildLocalizedPagesByTagId(ctx, locale);
+    ctx.pagesByTagId.set(locale.code, localizedPageByTagId);
+    return localizedPageByTagId;
+};

package/dist/es6/impl/sitemap/helpers/localized-path.js

@@ -0,0 +1,4 @@
+export var localizedPath = function (localeCode, path) {
+    var pathLocalePrefix = "/" + localeCode;
+    return path ? pathLocalePrefix + path : pathLocalePrefix;
+};

package/dist/es6/impl/sitemap/helpers/page-ancestors.js

@@ -0,0 +1,8 @@
+import { toArboretumPageWithMissingData } from '../adapters/to-arboretum-page-with-missing-data-adapter';
+import { findAncestors } from './find-ancestors';
+export var pageAncestors = function (localeCode, sitemap, page) {
+    var ancestors = findAncestors(sitemap, page);
+    return ancestors === null || ancestors === void 0 ? void 0 : ancestors.map(function (ancestor) {
+        return toArboretumPageWithMissingData(localeCode)(ancestor, undefined, undefined);
+    });
+};

package/dist/es6/impl/sitemap/helpers/page-children.js

@@ -0,0 +1,10 @@
+import { redirectToArboretumPage } from '../adapters/redirect-to-arboretum-page-adapter';
+import { toArboretumPageWithMissingData } from '../adapters/to-arboretum-page-with-missing-data-adapter';
+import { findChildren } from './find-children';
+export var pageChildren = function (localeCode, sitemap, page) {
+    return findChildren(sitemap)(page).map(function (childPage) {
+        return childPage.type === 'page'
+            ? toArboretumPageWithMissingData(localeCode)(childPage, undefined, undefined)
+            : redirectToArboretumPage(localeCode)(childPage);
+    });
+};

package/dist/es6/impl/sitemap/methods/cached-data.js

@@ -0,0 +1,7 @@
+export var cachedData = function (ctx) {
+    return function () { return ({
+        data: ctx.data,
+        sitemap: ctx.sitemap,
+        pagesByTagId: ctx.pagesByTagId,
+    }); };
+};

package/dist/es6/impl/sitemap/methods/home-page.js

@@ -0,0 +1,27 @@
+import { left, right } from "../../../utils/fp-utils";
+import { localizedSitemapFromCacheOrBuildEff } from "../helpers/build-localized-sitemap";
+import { toArboretumPage } from "../adapters/to-arboretum-page-adapter";
+export var homePage = function (ctx) {
+    return function (localeCode, options) {
+        var locale = ctx.data.locales.get(localeCode);
+        if (locale) {
+            var sitemap = localizedSitemapFromCacheOrBuildEff(ctx, locale);
+            if (sitemap._tag === "Right") {
+                var id = sitemap.right.root.sys.id;
+                var page = sitemap.right.sitemap.get(id);
+                if (page && page.type === "page") {
+                    return right(toArboretumPage(sitemap.right, localeCode, options)(page));
+                }
+                else {
+                    return left("Failed to find home page by id: ".concat(id, " and locale: ").concat(locale.code));
+                }
+            }
+            else {
+                return left(sitemap.left);
+            }
+        }
+        else {
+            return left("Failed to find locale by code: ".concat(localeCode));
+        }
+    };
+};

package/dist/es6/impl/sitemap/methods/page-by-id.js

@@ -0,0 +1,29 @@
+import { left, right } from '../../../utils/fp-utils';
+import { localizedSitemapFromCacheOrBuildEff } from '../helpers/build-localized-sitemap';
+import { toArboretumPage } from '../adapters/to-arboretum-page-adapter';
+import { redirectToArboretumPage } from '../adapters/redirect-to-arboretum-page-adapter';
+export var pageById = function (ctx) {
+    return function (localeCode, id, options) {
+        var locale = ctx.data.locales.get(localeCode);
+        if (locale) {
+            var sitemap = localizedSitemapFromCacheOrBuildEff(ctx, locale);
+            if (sitemap._tag === 'Right') {
+                var page = sitemap.right.sitemap.get(id);
+                if (page) {
+                    return right(page.type === 'page'
+                        ? toArboretumPage(sitemap.right, localeCode, options)(page)
+                        : redirectToArboretumPage(locale.code)(page));
+                }
+                else {
+                    return left("Failed to find page by id: ".concat(id, " and locale: ").concat(locale.code));
+                }
+            }
+            else {
+                return left(sitemap.left);
+            }
+        }
+        else {
+            return left("Failed to find locale by code: ".concat(localeCode));
+        }
+    };
+};

package/dist/es6/impl/sitemap/methods/page-by-path.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;
+};
+import { left, right } from '../../../utils/fp-utils';
+import { localizedSitemapFromCacheOrBuildEff } from '../helpers/build-localized-sitemap';
+import { toArboretumPage } from '../adapters/to-arboretum-page-adapter';
+import { redirectToArboretumPage } from '../adapters/redirect-to-arboretum-page-adapter';
+export var pageByPath = function (ctx) {
+    return function (path, options) {
+        if (path.length) {
+            var _a = __read(path.split('/').filter(function (slug) { return !!slug; }), 1), localeCode = _a[0];
+            var locale = ctx.data.locales.get(localeCode);
+            if (locale) {
+                var sitemap = localizedSitemapFromCacheOrBuildEff(ctx, locale);
+                if (sitemap._tag === 'Right') {
+                    var pageId = sitemap.right.pageIdByPath.get(path.startsWith("/") ? path : "/" + path);
+                    var page = pageId ? sitemap.right.sitemap.get(pageId) : undefined;
+                    if (page) {
+                        return right(page.type === 'page'
+                            ? toArboretumPage(sitemap.right, localeCode, options)(page)
+                            : redirectToArboretumPage(locale.code)(page));
+                    }
+                    else {
+                        return left("Failed to find page by path: ".concat(path));
+                    }
+                }
+                else {
+                    return left(sitemap.left);
+                }
+            }
+            else {
+                return left("Failed to find locale by code: ".concat(localeCode));
+            }
+        }
+        else {
+            return left("Path can't be empty");
+        }
+    };
+};

package/dist/es6/impl/sitemap/methods/pages-by-ids.js

@@ -0,0 +1,6 @@
+import { pageById } from './page-by-id';
+export var pagesByIds = function (ctx) {
+    return function (localeCode, ids, options) {
+        return ids.map(function (id) { return pageById(ctx)(localeCode, id, options); });
+    };
+};

package/dist/es6/impl/sitemap/methods/pages-by-paths.js

@@ -0,0 +1,6 @@
+import { pageByPath } from './page-by-path';
+export var pagesByPaths = function (ctx) {
+    return function (paths, options) {
+        return paths.map(function (path) { return pageByPath(ctx)(path, options); });
+    };
+};

package/dist/es6/impl/sitemap/methods/pages-by-tag-id.js

@@ -0,0 +1,37 @@
+import { left, right } from '../../../utils/fp-utils';
+import { localizedSitemapFromCacheOrBuildEff } from '../helpers/build-localized-sitemap';
+import { toArboretumPage } from '../adapters/to-arboretum-page-adapter';
+import { redirectToArboretumPage } from '../adapters/redirect-to-arboretum-page-adapter';
+import { localizedPagesByTagIdFromCacheOrBuildEff } from '../helpers/localized-pages-by-tag-id';
+export var pagesByTagId = function (ctx) {
+    return function (localeCode, tagId, options) {
+        var _a;
+        var locale = ctx.data.locales.get(localeCode);
+        if (locale) {
+            var pagesByTagId_1 = localizedPagesByTagIdFromCacheOrBuildEff(ctx, locale);
+            var sitemap_1 = localizedSitemapFromCacheOrBuildEff(ctx, locale);
+            if (pagesByTagId_1._tag === 'Left') {
+                return pagesByTagId_1;
+            }
+            else if (sitemap_1._tag === 'Left') {
+                return sitemap_1;
+            }
+            else {
+                var pages = ((_a = pagesByTagId_1.right.get(tagId)) === null || _a === void 0 ? void 0 : _a.flatMap(function (_a) {
+                    var sys = _a.sys;
+                    var page = sitemap_1.right.sitemap.get(sys.id);
+                    var arboretumPage = (page === null || page === void 0 ? void 0 : page.type) === 'page'
+                        ? toArboretumPage(sitemap_1.right, locale.code, options)(page)
+                        : page
+                            ? redirectToArboretumPage(locale.code)(page)
+                            : undefined;
+                    return arboretumPage ? [arboretumPage] : [];
+                })) || [];
+                return right(pages);
+            }
+        }
+        else {
+            return left("Failed to find locale by code: ".concat(localeCode));
+        }
+    };
+};

package/dist/es6/impl/sitemap/methods/pages.js

@@ -0,0 +1,75 @@
+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 { left, right } from '../../../utils/fp-utils';
+import { localizedSitemapFromCacheOrBuildEff } from '../helpers/build-localized-sitemap';
+import { toArboretumPage } from '../adapters/to-arboretum-page-adapter';
+import { redirectToArboretumPage } from '../adapters/redirect-to-arboretum-page-adapter';
+var singleOrAllLocalesE = function (locales) {
+    return function (localeCode) {
+        if (localeCode) {
+            var locale = locales.get(localeCode);
+            return locale
+                ? right([locale])
+                : left("Failed to find locale by code: ".concat(localeCode));
+        }
+        else {
+            return right(__spreadArray([], __read(locales.values()), false));
+        }
+    };
+};
+export var pages = function (ctx) {
+    return function (options) {
+        var localeCode = options === null || options === void 0 ? void 0 : options.localeCode;
+        var localesE = singleOrAllLocalesE(ctx.data.locales)(localeCode);
+        var skip = typeof (options === null || options === void 0 ? void 0 : options.skip) !== 'undefined' ? options.skip : 0;
+        if (localesE._tag === 'Right') {
+            var pages_1 = localesE.right
+                .flatMap(function (locale) {
+                var localizedSitemapE = localizedSitemapFromCacheOrBuildEff(ctx, locale);
+                var pages = localizedSitemapE._tag === 'Right'
+                    ? __spreadArray([], __read(localizedSitemapE.right.sitemap.values()), false).map(function (p) {
+                        return p.type === 'page'
+                            ? toArboretumPage(localizedSitemapE.right, locale.code, options)(p)
+                            : redirectToArboretumPage(locale.code)(p);
+                    })
+                    : [];
+                return pages;
+            })
+                .sort(function (p1, p2) {
+                if (p1.id < p2.id)
+                    return -1;
+                if (p1.id > p2.id)
+                    return 1;
+                return 0;
+            })
+                .slice(skip, options === null || options === void 0 ? void 0 : options.limit);
+            return right(pages_1);
+        }
+        else {
+            return localesE;
+        }
+    };
+};

package/dist/es6/impl/sitemap/methods/regenerate.js

@@ -0,0 +1,64 @@
+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 };
+    }
+};
+import { sitemapData } from '../../data/sitemap-data';
+export var regenerate = function (ctx) {
+    return function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dataE;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx.regenerationInProgress = true;
+                    return [4 /*yield*/, sitemapData(ctx).finally(function () {
+                            ctx.regenerationInProgress = false;
+                        })];
+                case 1:
+                    dataE = _a.sent();
+                    if (dataE._tag === 'Right') {
+                        ctx.sitemap = new Map();
+                        ctx.pagesByTagId = new Map();
+                        ctx.lastUpdatedAt = new Date().toISOString();
+                        ctx.data = dataE.right.data;
+                        return [2 /*return*/, { status: 'OK', warnings: dataE.right.warnings }];
+                    }
+                    else {
+                        throw new Error(dataE.left.join('\n'));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+};