@bright.global/arboretum-sdk 0.0.6

package/dist/es6/impl/sitemap/helpers/__mocks__/mocked-localized-sitemap.js

@@ -0,0 +1,186 @@
+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 mockedRootSysId = 'root';
+var mockedPage1SysId = 'page1';
+var mockedPage1_1SysId = 'page1-1';
+var mockedPage1_1_1SysId = 'page1-1-1';
+var mockedPage1_1_2SysId = 'page1-1-2';
+var mockedPage1_2SysId = 'page1-2';
+var mockedPage2SysId = 'page2';
+var mockedPage2_1SysId = 'page2_1';
+var mockedPage3SysId = 'page3';
+var mockedRedirect1SysId = 'redirect1';
+var mockedRedirect2SysId = 'redirect2';
+var mockedRedirect3SysId = 'redirect3';
+export var mockedRoot = {
+    type: 'page',
+    sys: { id: mockedRootSysId },
+    parent: undefined,
+    slug: mockedRootSysId,
+    path: '/en',
+    childPages: [
+        { sys: { id: mockedPage1SysId } },
+        { sys: { id: mockedPage2SysId } },
+        { sys: { id: mockedPage3SysId } },
+        { sys: { id: mockedRedirect1SysId } },
+        { sys: { id: mockedRedirect2SysId } },
+        { sys: { id: mockedRedirect3SysId } },
+    ],
+};
+export var mockedPage1 = {
+    type: 'page',
+    sys: { id: mockedPage1SysId },
+    parent: { sys: mockedRoot.sys },
+    slug: mockedPage1SysId,
+    path: mockedRoot.path + '/' + mockedPage1SysId,
+    childPages: [
+        { sys: { id: mockedPage1_1SysId } },
+        { sys: { id: mockedPage1_2SysId } },
+    ],
+};
+export var mockedPage1_1 = {
+    type: 'page',
+    sys: { id: mockedPage1_1SysId },
+    parent: { sys: mockedPage1.sys },
+    path: mockedPage1.path + '/' + mockedPage1_1SysId,
+    slug: mockedPage1_1SysId,
+    childPages: [
+        { sys: { id: mockedPage1_1_1SysId } },
+        { sys: { id: mockedPage1_1_2SysId } },
+    ],
+};
+export var mockedPage1_2 = {
+    type: 'page',
+    sys: { id: mockedPage1_2SysId },
+    parent: { sys: mockedPage1.sys },
+    path: mockedPage1.path + '/' + mockedPage1_2SysId,
+    slug: mockedPage1_2SysId,
+    childPages: [],
+};
+export var mockedPage1_1_1 = {
+    type: 'page',
+    sys: { id: mockedPage1_1_1SysId },
+    parent: { sys: mockedPage1_1.sys },
+    path: mockedPage1_1.path + '/' + mockedPage1_1_1SysId,
+    slug: mockedPage1_1_1SysId,
+    childPages: [],
+};
+export var mockedPage1_1_2 = {
+    type: 'page',
+    sys: { id: mockedPage1_1_2SysId },
+    parent: { sys: mockedPage1_1.sys },
+    path: mockedPage1_1.path + '/' + mockedPage1_1_2SysId,
+    slug: mockedPage1_1_2SysId,
+    childPages: [],
+};
+export var mockedPage2 = {
+    type: 'page',
+    sys: { id: mockedPage2SysId },
+    parent: { sys: mockedRoot.sys },
+    path: mockedRoot.path + '/' + mockedPage2SysId,
+    slug: mockedPage2SysId,
+    childPages: [{ sys: { id: mockedPage2_1SysId } }],
+};
+export var mockedPage2_1 = {
+    type: 'page',
+    sys: { id: mockedPage2_1SysId },
+    parent: { sys: mockedPage2.sys },
+    path: mockedPage2.path + '/' + mockedPage2_1SysId,
+    slug: mockedPage2_1SysId,
+    childPages: [],
+};
+export var mockedPage3 = {
+    type: 'page',
+    sys: { id: mockedPage3SysId },
+    parent: { sys: mockedRoot.sys },
+    path: mockedRoot.path + '/' + mockedPage3SysId,
+    slug: mockedPage3SysId,
+    childPages: [],
+};
+var mockedRedirect1 = {
+    type: 'alias',
+    sys: { id: mockedRedirect1SysId },
+    page: { sys: { id: mockedRedirect1SysId } },
+    path: mockedRoot.path + '/' + mockedRedirect1SysId,
+    parent: { sys: { id: mockedRoot.sys.id } },
+};
+var mockedRedirect2 = {
+    type: 'redirect',
+    sys: { id: mockedRedirect2SysId },
+    page: { sys: { id: mockedRedirect2SysId } },
+    path: mockedRoot.path + '/' + mockedRedirect2SysId,
+    parent: { sys: { id: mockedRoot.sys.id } },
+};
+var mockedRedirect3 = {
+    type: 'alias',
+    sys: { id: mockedRedirect3SysId },
+    page: { sys: { id: mockedRedirect3SysId } },
+    path: mockedRoot.path + '/' + mockedRedirect3SysId,
+    parent: { sys: { id: mockedRoot.sys.id } },
+};
+export var mockedRedirects = [
+    mockedRedirect1,
+    mockedRedirect2,
+    mockedRedirect3,
+];
+export var mockedPages = __spreadArray([
+    mockedRoot,
+    mockedPage1,
+    mockedPage1_1,
+    mockedPage1_1_1,
+    mockedPage1_1_2,
+    mockedPage1_2,
+    mockedPage2,
+    mockedPage2_1,
+    mockedPage3
+], __read(mockedRedirects), false);
+export var mockedLocalizedSitemap = {
+    root: { sys: mockedRoot.sys },
+    sitemap: new Map(mockedPages.map(function (page) {
+        if (!page.parent && page.type === 'page') {
+            return [page.sys.id, page];
+        }
+        return [page.sys.id, page];
+    })),
+    pageIdByPath: new Map(mockedPages.map(function (page) { return [page.path, page.sys.id]; })),
+};
+export var mockedPage1WithCircularReference = {
+    type: 'page',
+    sys: { id: mockedPage1SysId },
+    parent: { sys: { id: mockedRoot.sys.id } },
+    path: mockedRoot.path + '/' + mockedPage1SysId,
+    slug: mockedPage1SysId,
+    childPages: [{ sys: { id: mockedRootSysId } }],
+};
+export var mockedCircularReferencesPages = [
+    mockedRoot,
+    mockedPage1WithCircularReference,
+];
+export var mockedLocalizedSitemapWithCircularReference = {
+    root: { sys: mockedRoot.sys },
+    sitemap: new Map(mockedCircularReferencesPages.map(function (page) { return [page.sys.id, page]; })),
+    pageIdByPath: new Map(mockedCircularReferencesPages.map(function (page) { return [page.path, page.sys.id]; })),
+};

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

@@ -0,0 +1,128 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { pageEntryAdapter } from '../adapters/page-entry-adapter';
+import { redirectEntryAdapter } from '../adapters/redirect-entry-adapter';
+import { isRoot } from './is-root';
+var getAllRedirects = function (data, options, locale, parent) {
+    var redirectContentType = options.id
+        ? data.contentTypes.get(options.id)
+        : undefined;
+    var findField = function (fieldId) {
+        return redirectContentType === null || redirectContentType === void 0 ? void 0 : redirectContentType.fields.get(fieldId);
+    };
+    var pageField = findField(options.pageFieldId);
+    var pathField = findField(options.pathFieldId);
+    var typeField = findField(options.typeFieldId);
+    var titleField = options.titleFieldId
+        ? findField(options.titleFieldId)
+        : undefined;
+    return data.redirects.flatMap(function (redirectEntry) {
+        var redirect = pageField && pathField && typeField
+            ? redirectEntryAdapter(data, pageField, pathField, typeField, titleField, parent, locale, redirectEntry)
+            : undefined;
+        return redirect ? [redirect] : [];
+    });
+};
+var buildLocalizedSitemapArrRecursively = function (data, options, locale, parent, pageEntry, acc) {
+    var pages = data.pages, contentTypes = data.contentTypes;
+    var pageContentType = contentTypes.get(pageEntry.sys.contentType.sys.id);
+    var pageContentTypeConfig = options.pageContentTypes[pageEntry.sys.contentType.sys.id];
+    var findPageField = function (fieldId) {
+        return pageContentType && pageContentTypeConfig
+            ? pageContentType.fields.get(fieldId)
+            : undefined;
+    };
+    var slugField = findPageField(pageContentTypeConfig.slugFieldId);
+    var titleField = pageContentTypeConfig.titleFieldId
+        ? findPageField(pageContentTypeConfig.titleFieldId)
+        : undefined;
+    var childPagesField = pageContentTypeConfig.childPagesFieldId
+        ? findPageField(pageContentTypeConfig.childPagesFieldId)
+        : undefined;
+    var page = slugField
+        ? pageEntryAdapter(data, slugField, titleField, childPagesField, locale, parent, pageEntry)
+        : undefined;
+    if (page) {
+        var validChildPages_1 = page.childPages.filter(function (c) { return pages.get(c.sys.id) && !acc.get(c.sys.id); });
+        var redirectChildPages = isRoot(page) && options.redirectContentType
+            ? getAllRedirects(data, options.redirectContentType, locale, page)
+            : [];
+        redirectChildPages.forEach(function (r) {
+            var id = r.sys.id;
+            acc.set(id, r);
+            validChildPages_1.push({ sys: { id: id } });
+        });
+        var pageWithValidChildPages = __assign(__assign({}, page), { childPages: validChildPages_1 });
+        acc.set(page.sys.id, pageWithValidChildPages);
+        validChildPages_1.forEach(function (_a) {
+            var id = _a.sys.id;
+            var childPageEntry = pages.get(id);
+            childPageEntry &&
+                buildLocalizedSitemapArrRecursively(data, options, locale, { sys: pageEntry.sys, path: page.path }, childPageEntry, acc);
+        });
+        return acc;
+    }
+    else {
+        return acc;
+    }
+};
+export var buildLocalizedSitemap = function (data, options, pageHomeTagId, locale) {
+    var _a, _b, _c, _d;
+    var homePagesByTagId = data.homePagesByTagId, pages = data.pages;
+    var homePageRef = (_d = (_c = (_b = (_a = homePagesByTagId === null || homePagesByTagId === void 0 ? void 0 : homePagesByTagId.get(locale.code)) === null || _a === void 0 ? void 0 : _a.get(pageHomeTagId)) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.sys) === null || _d === void 0 ? void 0 : _d.id;
+    var homePageEntry = homePageRef ? pages.get(homePageRef) : undefined;
+    if (homePageEntry) {
+        var sitemap = buildLocalizedSitemapArrRecursively(data, options, locale, undefined, homePageEntry, new Map());
+        return right({
+            root: { sys: homePageEntry.sys },
+            sitemap: sitemap,
+            pageIdByPath: new Map(__spreadArray([], __read(sitemap.values()), false).map(function (page) { return [page.path, page.sys.id]; })),
+        });
+    }
+    else {
+        return left("Homepage required but not defined (locale: ".concat(locale.code, ")"));
+    }
+};
+export var localizedSitemapFromCacheOrBuildEff = function (ctx, locale) {
+    var cachedLocalizedSitemap = ctx.sitemap.get(locale.code);
+    var sitemapE = cachedLocalizedSitemap
+        ? cachedLocalizedSitemap
+        : buildLocalizedSitemap(ctx.data, ctx.options, ctx.pageHomeTagId, locale);
+    ctx.sitemap.set(locale.code, sitemapE);
+    return sitemapE;
+};

package/dist/es6/impl/sitemap/helpers/build-localized-sitemap.test.js

@@ -0,0 +1,208 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a;
+import { right } from '../../../utils/fp-utils';
+import { jsonStrigifyMapReplacer } from '../../../utils/json-stringify-map-replacer';
+import { buildLocalizedSitemap } from './build-localized-sitemap';
+import { mockedPages, mockedCircularReferencesPages, mockedPage1WithCircularReference, mockedRoot, mockedLocalizedSitemap, } from './__mocks__/mocked-localized-sitemap';
+var defaultLocale = {
+    code: 'en',
+    default: true,
+    fallbackCode: null,
+    name: 'English',
+};
+var pageContentTypeId = 'page';
+var pageContentTypeSlugFieldId = 'slug';
+var pageContentTypeChildPagesFieldId = 'childPages';
+var redirectContentTypeId = 'redirect';
+var redirectContentTypePage = 'page';
+var redirectContentTypePath = 'path';
+var redirectContentTypeType = 'type';
+var contentTypes = new Map([
+    [
+        pageContentTypeId,
+        {
+            sys: { id: pageContentTypeId },
+            fields: new Map([
+                [
+                    pageContentTypeSlugFieldId,
+                    {
+                        id: pageContentTypeSlugFieldId,
+                        localized: true,
+                        name: 'Slug',
+                        type: "Symbol"
+                    },
+                ],
+                [
+                    pageContentTypeChildPagesFieldId,
+                    {
+                        id: pageContentTypeChildPagesFieldId,
+                        localized: true,
+                        name: 'Child Pages',
+                        type: "Array"
+                    },
+                ],
+            ]),
+        },
+    ],
+    [
+        redirectContentTypeId,
+        {
+            sys: { id: redirectContentTypeId },
+            fields: new Map([
+                [
+                    redirectContentTypePage,
+                    {
+                        id: redirectContentTypePage,
+                        localized: true,
+                        name: 'Page',
+                        type: "Link"
+                    },
+                ],
+                [
+                    redirectContentTypePath,
+                    {
+                        id: redirectContentTypePath,
+                        localized: true,
+                        name: 'Path',
+                        type: "Symbol"
+                    },
+                ],
+                [
+                    redirectContentTypeType,
+                    {
+                        id: redirectContentTypeType,
+                        localized: true,
+                        name: 'Type',
+                        type: "Symbol"
+                    },
+                ],
+            ]),
+        },
+    ],
+]);
+var options = {
+    pageContentTypes: (_a = {},
+        _a[pageContentTypeId] = {
+            slugFieldId: pageContentTypeSlugFieldId,
+            childPagesFieldId: pageContentTypeChildPagesFieldId,
+        },
+        _a),
+    redirectContentType: {
+        id: redirectContentTypeId,
+        pageFieldId: redirectContentTypePage,
+        pathFieldId: redirectContentTypePath,
+        typeFieldId: redirectContentTypeType,
+    },
+};
+var pageToEntry = function (page, tagsIds) {
+    var _a, _b, _c;
+    return ({
+        sys: { id: page.sys.id, contentType: { sys: { id: pageContentTypeId } } },
+        metadata: tagsIds
+            ? { tags: tagsIds.map(function (t) { return ({ sys: { id: t } }); }) }
+            : undefined,
+        fields: (_a = {},
+            _a[pageContentTypeSlugFieldId] = (_b = {}, _b[defaultLocale.code] = page.slug, _b),
+            _a[pageContentTypeChildPagesFieldId] = (_c = {},
+                _c[defaultLocale.code] = page.childPages.map(function (cp) { return ({ sys: cp.sys }); }),
+                _c),
+            _a),
+    });
+};
+var redirectToEntry = function (page, tagsIds) {
+    var _a, _b, _c, _d;
+    return ({
+        sys: { id: page.sys.id, contentType: { sys: { id: redirectContentTypeId } } },
+        metadata: tagsIds
+            ? { tags: tagsIds.map(function (t) { return ({ sys: { id: t } }); }) }
+            : undefined,
+        fields: (_a = {},
+            _a[redirectContentTypePage] = (_b = {},
+                _b[defaultLocale.code] = { sys: { id: page.page.sys.id } },
+                _b),
+            _a[redirectContentTypePath] = (_c = {},
+                _c[defaultLocale.code] = page.path.slice(("/" + defaultLocale.code).length),
+                _c),
+            _a[redirectContentTypeType] = (_d = {},
+                _d[defaultLocale.code] = page.type,
+                _d),
+            _a),
+    });
+};
+describe(buildLocalizedSitemap, function () {
+    test('Not enough data to build sitemap', function () {
+        var emptyData = {
+            contentTypes: contentTypes,
+            defaultLocaleCode: defaultLocale.code,
+            locales: new Map([[defaultLocale.code, defaultLocale]]),
+            homePagesByTagId: new Map(),
+            pages: new Map(),
+            redirects: [],
+        };
+        expect(buildLocalizedSitemap(emptyData, { pageContentTypes: {} }, 'pageHome', defaultLocale)._tag).toBe('Left');
+    });
+    test('Build localized sitemap', function () {
+        var pageHomeTagId = 'pagHome';
+        var pagesEntries = mockedPages.flatMap(function (page) {
+            return page.type === 'page'
+                ? [pageToEntry(page, page.sys.id === 'root' ? [pageHomeTagId] : [])]
+                : [];
+        });
+        var redirectsEntries = mockedPages.flatMap(function (page) {
+            return page.type !== 'page' ? [redirectToEntry(page)] : [];
+        });
+        var data = {
+            contentTypes: contentTypes,
+            defaultLocaleCode: defaultLocale.code,
+            locales: new Map([[defaultLocale.code, defaultLocale]]),
+            homePagesByTagId: new Map([
+                [
+                    defaultLocale.code,
+                    new Map([[pageHomeTagId, [{ sys: { id: mockedRoot.sys.id } }]]]),
+                ],
+            ]),
+            pages: new Map(pagesEntries.map(function (e) { return [e.sys.id, e]; })),
+            redirects: redirectsEntries,
+        };
+        expect(JSON.parse(JSON.stringify(buildLocalizedSitemap(data, options, pageHomeTagId, defaultLocale), jsonStrigifyMapReplacer))).toMatchObject(JSON.parse(JSON.stringify(right(mockedLocalizedSitemap), jsonStrigifyMapReplacer)));
+    });
+    test('Handle reference cycles', function () {
+        var pageHomeTagId = 'pagHome';
+        var entries = mockedCircularReferencesPages.map(function (page) {
+            return pageToEntry(page, page.sys.id === 'root' ? [pageHomeTagId] : []);
+        });
+        var data = {
+            contentTypes: contentTypes,
+            defaultLocaleCode: defaultLocale.code,
+            locales: new Map([[defaultLocale.code, defaultLocale]]),
+            homePagesByTagId: new Map([
+                [
+                    defaultLocale.code,
+                    new Map([[pageHomeTagId, [{ sys: { id: mockedRoot.sys.id } }]]]),
+                ],
+            ]),
+            pages: new Map(entries.map(function (e) { return [e.sys.id, e]; })),
+            redirects: [],
+        };
+        var expectedLocalizedSitemap = right({
+            root: { sys: mockedRoot.sys },
+            sitemap: new Map([
+                __assign(__assign({}, mockedRoot), { childPages: [
+                        { sys: { id: mockedPage1WithCircularReference.sys.id } },
+                    ] }),
+                __assign(__assign({}, mockedPage1WithCircularReference), { childPages: [] }),
+            ].map(function (page) { return [page.sys.id, page]; })),
+        });
+        expect(JSON.parse(JSON.stringify(buildLocalizedSitemap(data, options, pageHomeTagId, defaultLocale), jsonStrigifyMapReplacer))).toMatchObject(JSON.parse(JSON.stringify(expectedLocalizedSitemap, jsonStrigifyMapReplacer)));
+    });
+});

package/dist/es6/impl/sitemap/helpers/build-pages-by-tag-eagerly.js

@@ -0,0 +1,7 @@
+import { arrayToMap } from '../../../utils/array-to-map';
+import { buildLocalizedPagesByTagId } from './localized-pages-by-tag-id';
+export var buildPagesByTagEagerly = function (ctx, locales) {
+    return arrayToMap(function (locale) { return locale.code; })(function (locale) {
+        return buildLocalizedPagesByTagId(ctx, locale);
+    })(Object.values(locales));
+};

package/dist/es6/impl/sitemap/helpers/build-sitemap-eagerly.js

@@ -0,0 +1,32 @@
+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 { buildLocalizedSitemap } from './build-localized-sitemap';
+import { arrayToMap } from '../../../utils/array-to-map';
+export var buildSitemapEagerly = function (ctx, locales) {
+    return arrayToMap(function (locale) { return locale.code; })(function (locale) {
+        return buildLocalizedSitemap(ctx.data, ctx.options, ctx.pageHomeTagId, locale);
+    })(__spreadArray([], __read(locales.values()), false));
+};

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

@@ -0,0 +1,42 @@
+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 findAncestorsRecursively = function (sitemap, page) {
+    var _a;
+    var maybeParentRef = (_a = page === null || page === void 0 ? void 0 : page.parent) === null || _a === void 0 ? void 0 : _a.sys;
+    var maybeParent = maybeParentRef
+        ? sitemap.get(maybeParentRef.id)
+        : undefined;
+    return maybeParent && maybeParent.type === 'page'
+        ? __spreadArray([maybeParent], __read(findAncestorsRecursively(sitemap, maybeParent)), false) : [];
+};
+export var findAncestors = function (_a, page) {
+    var root = _a.root, sitemap = _a.sitemap;
+    var ancestors = findAncestorsRecursively(sitemap, page);
+    var maybeHomePageAncestor = ancestors
+        .slice(-1)
+        .find(function (page) { return page.sys.id === root.sys.id; });
+    return maybeHomePageAncestor ? ancestors : undefined;
+};

package/dist/es6/impl/sitemap/helpers/find-ancestors.test.js

@@ -0,0 +1,33 @@
+import { findAncestors } from './find-ancestors';
+import { mockedPage1, mockedPage1_1, mockedPage1_1_1, mockedPage1_2, mockedPage2, mockedPage3, mockedRoot, mockedLocalizedSitemap, } from './__mocks__/mocked-localized-sitemap';
+describe(findAncestors, function () {
+    test('Get home page ancestors', function () {
+        expect(findAncestors(mockedLocalizedSitemap, mockedRoot)).toBeUndefined();
+    });
+    test('Get first level nodes ancestors', function () {
+        expect(findAncestors(mockedLocalizedSitemap, mockedPage1)).toEqual([
+            mockedRoot,
+        ]);
+        expect(findAncestors(mockedLocalizedSitemap, mockedPage2)).toEqual([
+            mockedRoot,
+        ]);
+        expect(findAncestors(mockedLocalizedSitemap, mockedPage3)).toEqual([
+            mockedRoot,
+        ]);
+    });
+    test('Get nested nodes ancestors', function () {
+        expect(findAncestors(mockedLocalizedSitemap, mockedPage1_1)).toEqual([
+            mockedPage1,
+            mockedRoot,
+        ]);
+        expect(findAncestors(mockedLocalizedSitemap, mockedPage1_1_1)).toEqual([
+            mockedPage1_1,
+            mockedPage1,
+            mockedRoot,
+        ]);
+        expect(findAncestors(mockedLocalizedSitemap, mockedPage1_2)).toEqual([
+            mockedPage1,
+            mockedRoot,
+        ]);
+    });
+});

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

@@ -0,0 +1,9 @@
+export var findChildren = function (sitemap) {
+    return function (page) {
+        return page.childPages.flatMap(function (_a) {
+            var id = _a.sys.id;
+            var childPage = sitemap.get(id);
+            return childPage ? [childPage] : [];
+        });
+    };
+};

package/dist/es6/impl/sitemap/helpers/find-children.test.js

@@ -0,0 +1,39 @@
+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 { findChildren } from './find-children';
+import { mockedPage1, mockedPage1_1, mockedPage1_1_1, mockedPage1_1_2, mockedPage2, mockedPage3, mockedRedirects, mockedRoot, mockedLocalizedSitemap, } from './__mocks__/mocked-localized-sitemap';
+describe(findChildren, function () {
+    test('Home page children with redirects', function () {
+        expect(findChildren(mockedLocalizedSitemap.sitemap)(mockedRoot)).toEqual(__spreadArray([
+            mockedPage1,
+            mockedPage2,
+            mockedPage3
+        ], __read(mockedRedirects), false));
+    });
+    test('Nested page children', function () {
+        expect(findChildren(mockedLocalizedSitemap.sitemap)(mockedPage1_1)).toEqual([mockedPage1_1_1, mockedPage1_1_2]);
+    });
+});