@bright.global/arboretum-sdk 0.0.6

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

@@ -0,0 +1,68 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regenerate = void 0;
+var sitemap_data_1 = require("../../data/sitemap-data");
+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*/, (0, sitemap_data_1.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*/];
+            }
+        });
+    }); };
+};
+exports.regenerate = regenerate;

package/dist/impl/sitemap/methods/search.js

@@ -0,0 +1,101 @@
+"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.search = void 0;
+var string_similarity_1 = require("../../../utils/string-similarity");
+var build_localized_sitemap_1 = require("../helpers/build-localized-sitemap");
+var to_arboretum_page_with_missing_data_adapter_1 = require("../adapters/to-arboretum-page-with-missing-data-adapter");
+var redirect_to_arboretum_page_adapter_1 = require("../adapters/redirect-to-arboretum-page-adapter");
+var minPhraseSimilarity = 0.4;
+var defaultLimit = 20;
+var pagePhraseSimilarity = function (page, path, phrase) {
+    var slugSimilarity = (0, string_similarity_1.stringSimilarity)(phrase, page.slug);
+    var pathSimilarity = (0, string_similarity_1.stringSimilarity)(phrase, path);
+    var idSimilarity = (0, string_similarity_1.stringSimilarity)(phrase, page.sys.id);
+    return Math.max.apply(Math, [slugSimilarity, pathSimilarity, idSimilarity]);
+};
+var redirectPhraseSimilarity = function (redirect, phrase) {
+    var pathSimilarity = (0, string_similarity_1.stringSimilarity)(phrase, redirect.path);
+    var idSimilarity = (0, string_similarity_1.stringSimilarity)(phrase, redirect.sys.id);
+    return Math.max.apply(Math, [pathSimilarity, idSimilarity]);
+};
+var localizedRecursiveSearch = function (localeCode, localizedSitemap, phrase, parentPath, currentPage) {
+    var getPath = function (page) {
+        return page.sys.id === localizedSitemap.root.sys.id
+            ? parentPath
+            : parentPath + '/' + page.slug;
+    };
+    var phraseSimilarity = currentPage.type === 'page'
+        ? pagePhraseSimilarity(currentPage, getPath(currentPage), phrase)
+        : redirectPhraseSimilarity(currentPage, phrase);
+    var childrenResults = currentPage.type === 'page'
+        ? currentPage.childPages.flatMap(function (_a) {
+            var id = _a.sys.id;
+            var childPage = localizedSitemap.sitemap.get(id);
+            var path = getPath(currentPage);
+            return childPage
+                ? localizedRecursiveSearch(localeCode, localizedSitemap, phrase, path, childPage)
+                : [];
+        })
+        : [];
+    var res = [];
+    if (phraseSimilarity >= minPhraseSimilarity) {
+        res.push({
+            phraseSimilarity: phraseSimilarity,
+            page: currentPage.type === 'page'
+                ? (0, to_arboretum_page_with_missing_data_adapter_1.toArboretumPageWithMissingData)(localeCode)(currentPage, undefined, undefined)
+                : (0, redirect_to_arboretum_page_adapter_1.redirectToArboretumPage)(localeCode)(currentPage),
+        });
+    }
+    res.push.apply(res, __spreadArray([], __read(childrenResults), false));
+    return res;
+};
+// Primitive implementation that can be inefficient for large sitemaps
+var search = function (ctx) {
+    return function (phrase, localeCode, limit) {
+        return __spreadArray([], __read(ctx.data.locales.values()), false).filter(function (locale) { return (localeCode ? locale.code === localeCode : true); })
+            .flatMap(function (locale) {
+            var sitemap = (0, build_localized_sitemap_1.localizedSitemapFromCacheOrBuildEff)(ctx, locale);
+            var homePage = sitemap._tag === 'Right'
+                ? sitemap.right.sitemap.get(sitemap.right.root.sys.id)
+                : undefined;
+            if (sitemap._tag === 'Right' && homePage) {
+                return localizedRecursiveSearch(locale.code, sitemap.right, phrase, "/".concat(locale.code), homePage);
+            }
+            else {
+                return [];
+            }
+        })
+            .sort(function (a, b) { return b.phraseSimilarity - a.phraseSimilarity; })
+            .slice(0, limit || defaultLimit)
+            .map(function (_a) {
+            var page = _a.page;
+            return page;
+        });
+    };
+};
+exports.search = search;

package/dist/impl/sitemap/methods/status.js

@@ -0,0 +1,51 @@
+"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.status = void 0;
+var build_localized_sitemap_1 = require("../helpers/build-localized-sitemap");
+var status = function (ctx) {
+    return function () {
+        var pagesCount = __spreadArray([], __read(ctx.data.locales.values()), false).reduce(function (acc, locale) {
+            var sitemap = (0, build_localized_sitemap_1.localizedSitemapFromCacheOrBuildEff)(ctx, locale);
+            if (sitemap._tag === 'Right') {
+                return sitemap.right.sitemap.size + acc;
+            }
+            else {
+                return acc;
+            }
+        }, 0);
+        var localesCount = ctx.data.locales.size;
+        return {
+            pagesCount: pagesCount,
+            localesCount: localesCount,
+            lastUpdatedAt: ctx.lastUpdatedAt,
+            contentful: ctx.options,
+            regenerationInProgress: ctx.regenerationInProgress
+        };
+    };
+};
+exports.status = status;

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArboretumClientFromCdaParams = exports.createArboretumClientFromCdaClient = exports.createArboretumClientFromCma = exports.createArboretumClient = void 0;
+var arboretum_client_impl_1 = require("./impl/arboretum-client.impl");
+Object.defineProperty(exports, "createArboretumClient", { enumerable: true, get: function () { return arboretum_client_impl_1.createArboretumClient; } });
+Object.defineProperty(exports, "createArboretumClientFromCma", { enumerable: true, get: function () { return arboretum_client_impl_1.createArboretumClientFromCma; } });
+Object.defineProperty(exports, "createArboretumClientFromCdaClient", { enumerable: true, get: function () { return arboretum_client_impl_1.createArboretumClientFromCdaClient; } });
+Object.defineProperty(exports, "createArboretumClientFromCdaParams", { enumerable: true, get: function () { return arboretum_client_impl_1.createArboretumClientFromCdaParams; } });

package/dist/types/arboretum-client.d.ts

@@ -0,0 +1,110 @@
+import { ContentfulClientApi, CreateClientParams } from "contentful";
+import { CachedDataT, SysIdT } from "./impl/arboretum-client.impl";
+import { Either } from "./utils/fp-utils";
+import { ContentfulEnvironmentAPI } from "contentful-management/dist/typings/create-environment-api";
+import { LocaleT, StatusT } from "./clients/contentful-client/contentful-client";
+export type ArboretumClientOptions = {
+    data?: CachedDataT;
+    eagerly?: boolean;
+    includeEntryStatus?: boolean;
+};
+export type ArboretumClientContentfulConfigOptionsT = {
+    pageContentTypes: {
+        [id: SysIdT]: {
+            slugFieldId: string;
+            titleFieldId?: string;
+            childPagesFieldId?: string;
+        };
+    };
+    redirectContentType?: {
+        id: string;
+        titleFieldId?: string;
+        pageFieldId: string;
+        pathFieldId: string;
+        typeFieldId: string;
+    };
+    homePageTagId?: string;
+};
+export type ArboretumClientConfigFromCmaT = {
+    type: "cma-client";
+    preview: boolean;
+    contentful: {
+        client: ContentfulEnvironmentAPI;
+        options: ArboretumClientContentfulConfigOptionsT;
+    };
+    options?: ArboretumClientOptions;
+};
+export type ArboretumClientConfigFromCdaT = {
+    type: "cda-client";
+    preview: boolean;
+    contentful: {
+        client: ContentfulClientApi;
+        options: ArboretumClientContentfulConfigOptionsT;
+    };
+    options?: Pick<ArboretumClientOptions, "data" | "eagerly">;
+};
+export type ArboretumClientConfigFromCdaParamsT = {
+    type: "cda-client-params";
+    preview: boolean;
+    contentful: CreateClientParams & {
+        options: ArboretumClientContentfulConfigOptionsT;
+    };
+    options?: Pick<ArboretumClientOptions, "data" | "eagerly">;
+};
+export type ArboretumClientConfigT = ArboretumClientConfigFromCmaT | ArboretumClientConfigFromCdaT | ArboretumClientConfigFromCdaParamsT;
+type ArboretumPageBaseT = {
+    id: string;
+    localeCode: string;
+    path: string;
+    title?: string;
+    cmaOnlyStatus?: StatusT;
+};
+export type ArboretumRedirectT = ArboretumPageBaseT & {
+    type: "redirect";
+    pageId: string;
+};
+export type ArboretumAliasT = ArboretumPageBaseT & {
+    type: "alias";
+    pageId: string;
+};
+export type ArboretumPageT = ArboretumPageBaseT & {
+    type: "page";
+    slug: string;
+    totalDirectChildrenCount: number;
+    children?: Array<ArboretumPageNodeT>;
+    ancestors?: Array<Omit<ArboretumPageT, "children" | "ancestors">>;
+};
+export type ArboretumPageNodeT = ArboretumPageT | ArboretumRedirectT | ArboretumAliasT;
+export type OptionsT = {
+    withChildren?: boolean;
+    withAncestors?: boolean;
+};
+export type ArboretumClientOptionsT = Pick<ArboretumClientContentfulConfigOptionsT, "pageContentTypes" | "redirectContentType"> & Pick<ArboretumClientOptions, "includeEntryStatus">;
+export type ArboretumClientT = {
+    homePage: (localeCode: string, options?: OptionsT) => Either<string, ArboretumPageT>;
+    pageByPath: (path: string, options?: OptionsT) => Either<string, ArboretumPageNodeT>;
+    pagesByPaths: (paths: Array<string>, options?: OptionsT) => Array<Either<string, ArboretumPageNodeT>>;
+    pageById: (localeCode: string, id: string, options?: OptionsT) => Either<string, ArboretumPageNodeT>;
+    pagesByIds: (localeCode: string, ids: Array<string>, options?: OptionsT) => Array<Either<string, ArboretumPageNodeT>>;
+    pagesByTagId: (localeCode: string, tagId: string, options?: OptionsT) => Either<string, Array<ArboretumPageNodeT>>;
+    pages: (options?: OptionsT & {
+        limit?: number;
+        skip?: number;
+        localeCode?: string;
+    }) => Either<string, Array<ArboretumPageNodeT>>;
+    locales: () => Array<LocaleT>;
+    regenerate: () => Promise<{
+        status: "OK";
+        warnings?: Array<string>;
+    }>;
+    search: (phrase: string, localeCode?: string, limit?: number) => Array<ArboretumPageNodeT>;
+    status: () => {
+        lastUpdatedAt: string;
+        pagesCount: number;
+        localesCount: number;
+        contentful: ArboretumClientOptionsT;
+        regenerationInProgress: boolean;
+    };
+    cachedData: () => CachedDataT;
+};
+export {};

package/dist/types/clients/contentful-client/contentful-client.d.ts

@@ -0,0 +1,95 @@
+import { Entry, Locale } from "contentful";
+type EntriesQueryT = {
+    limit?: number;
+    skip?: number;
+    content_type?: string;
+    include?: number;
+    select?: string;
+    locale?: string;
+    ["metadata.tags.sys.id[in]"]?: string;
+    order?: string;
+    [key: string]: any;
+};
+type ContentTypesQueryT = {
+    limit: number;
+    "sys.id[in]": string;
+};
+export type StatusT = "draft" | "published" | "changed" | "archived";
+export type EntryT = {
+    metadata?: {
+        tags: Array<{
+            sys: {
+                id: string;
+            };
+        }>;
+    };
+    fields: Entry<any>["fields"];
+    sys: {
+        id: string;
+        archivedVersion?: number;
+        version?: number;
+        publishedVersion?: number;
+        contentType: {
+            sys: {
+                id: string;
+            };
+        };
+        cmaOnlyStatus?: StatusT;
+    };
+};
+export type EntryIdT = EntryT["sys"]["id"];
+type TagsQueryT = {
+    limit?: number;
+    skip?: number;
+    [key: string]: any;
+};
+export type TagT = {
+    name: string;
+    sys: {
+        id: string;
+    };
+};
+export type LocaleT = Pick<Locale, "code" | "default" | "fallbackCode" | "name">;
+export type ContentTypeT = {
+    sys: {
+        id: string;
+    };
+    fields: Array<{
+        id: string;
+        name: string;
+        localized: boolean;
+        type: string;
+        linkType?: string;
+        items?: {
+            type?: string;
+            linkType?: string;
+        };
+    }>;
+};
+export type ContentfulClientT = {
+    getEntries: (query?: EntriesQueryT) => Promise<{
+        skip: number;
+        limit: number;
+        total: number;
+        items: Array<EntryT>;
+    }>;
+    getLocales: () => Promise<{
+        skip: number;
+        limit: number;
+        total: number;
+        items: Array<LocaleT>;
+    }>;
+    getContentTypes: (query?: ContentTypesQueryT) => Promise<{
+        skip: number;
+        limit: number;
+        total: number;
+        items: Array<ContentTypeT>;
+    }>;
+    getTags: (query?: TagsQueryT) => Promise<{
+        skip: number;
+        limit: number;
+        total: number;
+        items: Array<TagT>;
+    }>;
+};
+export {};

package/dist/types/clients/contentful-client/impl/contentful-client-impl.d.ts

@@ -0,0 +1,3 @@
+import { ArboretumClientConfigT } from "../../../arboretum-client";
+import { ContentfulClientT } from "../contentful-client";
+export declare const createContentfulClient: (config: ArboretumClientConfigT) => ContentfulClientT;

package/dist/types/impl/arboretum-client.impl.d.ts

@@ -0,0 +1,107 @@
+import { ArboretumClientConfigFromCdaParamsT, ArboretumClientConfigFromCdaT, ArboretumClientConfigFromCmaT, ArboretumClientConfigT, ArboretumClientT, ArboretumClientOptionsT } from "../arboretum-client";
+import { ContentfulClientT, StatusT } from "../clients/contentful-client/contentful-client";
+import { SitemapDataT } from "./data/sitemap-data";
+import { Either } from "../utils/fp-utils";
+export type LocaleCodeT = string;
+export type SysIdT = string;
+export type MetadataT = {
+    tags: Array<{
+        sys: {
+            id: string;
+        };
+    }>;
+};
+export type PageT = {
+    type: "page";
+    sys: {
+        id: string;
+        cmaOnlyStatus?: StatusT;
+    };
+    metadata?: MetadataT;
+    parent: {
+        sys: {
+            id: string;
+        };
+    } | undefined;
+    path: string;
+    slug: string;
+    title?: string;
+    childPages: Array<{
+        sys: {
+            id: string;
+        };
+    }>;
+};
+export type RedirectT = {
+    sys: {
+        id: string;
+        cmaOnlyStatus?: StatusT;
+    };
+    parent: {
+        sys: {
+            id: string;
+        };
+    };
+    metadata?: MetadataT;
+    path: string;
+    title?: string;
+    type: "redirect" | "alias";
+    page: {
+        sys: {
+            id: string;
+        };
+    };
+};
+export type RedirectIdT = RedirectT["sys"]["id"];
+export type RedirectPathT = RedirectT["path"];
+export type PageIdT = (PageT | RedirectT)["sys"]["id"];
+export type PagePathT = (PageT | RedirectT)["path"];
+export type TagIdT = string;
+export type LocalizedSitemapT = {
+    root: {
+        sys: {
+            id: string;
+        };
+    };
+    sitemap: Map<PageIdT, PageT | RedirectT>;
+    pageIdByPath: Map<PagePathT, PageIdT>;
+};
+export type SitemapT = Map<LocaleCodeT, Either<string, LocalizedSitemapT>>;
+export type PagesByTagIdV = Either<string, Map<TagIdT, Array<{
+    sys: {
+        id: SysIdT;
+    };
+}>>>;
+export type PagesByTagIdT = Map<LocaleCodeT, PagesByTagIdV>;
+export type CachedDataT = Pick<ArboretumClientCtx, "data" | "pagesByTagId" | "sitemap">;
+export type ArboretumClientCtx = {
+    preview: boolean;
+    contentfulClientType: ArboretumClientConfigT["type"];
+    lastUpdatedAt: string;
+    clientApi: ContentfulClientT;
+    cmaPreviewClientApi?: ContentfulClientT;
+    options: ArboretumClientOptionsT;
+    data: SitemapDataT;
+    sitemap: SitemapT;
+    pagesByTagId: PagesByTagIdT;
+    localeTagIdPrefix: string;
+    pageTagIdPrefix: string;
+    pageHomeTagId: string;
+    regenerationInProgress: boolean;
+};
+export declare const createArboretumClient: (config: ArboretumClientConfigT) => Promise<{
+    client: ArboretumClientT;
+    warnings?: Array<string>;
+}>;
+export declare const createArboretumClientFromCdaClient: (config: Pick<ArboretumClientConfigFromCdaT, "contentful" | "preview" | "options">) => Promise<{
+    client: ArboretumClientT;
+    warnings?: string[] | undefined;
+}>;
+export declare const createArboretumClientFromCdaParams: (config: Pick<ArboretumClientConfigFromCdaParamsT, "contentful" | "preview" | "options">) => Promise<{
+    client: ArboretumClientT;
+    warnings?: string[] | undefined;
+}>;
+export declare const createArboretumClientFromCma: (config: Pick<ArboretumClientConfigFromCmaT, "contentful" | "preview" | "options">) => Promise<{
+    client: ArboretumClientT;
+    warnings?: string[] | undefined;
+}>;

package/dist/types/impl/data/content-types.d.ts

@@ -0,0 +1,11 @@
+import { ArboretumClientCtx, SysIdT } from '../arboretum-client.impl';
+import { ContentTypeT } from '../../clients/contentful-client/contentful-client';
+export type ContentTypesT = Map<SysIdT, Pick<ContentTypeT, 'sys'> & {
+    fields: Map<SysIdT, ContentTypeT['fields'][number]>;
+}>;
+type ContentTypesR = {
+    contentTypes: ContentTypesT;
+    warnings?: Array<string>;
+};
+export declare const contentTypes: (ctx: Pick<ArboretumClientCtx, 'clientApi' | 'options'>) => Promise<ContentTypesR>;
+export {};

package/dist/types/impl/data/helpers/__mocks__/mocked-contentful-entries-client-api.d.ts

@@ -0,0 +1,7 @@
+import { ArboretumClientCtx } from '../../../arboretum-client.impl';
+export declare const mockedEntrySysId: (contentType: string, idx: number) => string;
+export declare const mockedContentfulEntriesClientApi: (contentType: string, total: number) => Pick<ArboretumClientCtx['clientApi'], 'getEntries'>;
+export declare const multipleContentTypesMockedContentfulEntriesClientApi: (contentTypes: Array<{
+    contentType: string;
+    total: number;
+}>) => Pick<ArboretumClientCtx['clientApi'], 'getEntries'>;

package/dist/types/impl/data/helpers/entry-status.d.ts

@@ -0,0 +1,2 @@
+import { EntryT, StatusT } from "../../../clients/contentful-client/contentful-client";
+export declare const entryStatus: (sys: Pick<EntryT["sys"], "archivedVersion" | "version" | "publishedVersion">) => StatusT | undefined;

package/dist/types/impl/data/helpers/get-all-entries-recursively.d.ts

@@ -0,0 +1,6 @@
+import { EntryT } from "../../../clients/contentful-client/contentful-client";
+import { ArboretumClientCtx, SysIdT } from "../../arboretum-client.impl";
+export type PagesT = {
+    [sys: SysIdT]: EntryT;
+};
+export declare const getAllEntriesRecursively: ({ getEntries }: Pick<ArboretumClientCtx["clientApi"], "getEntries">, contentType: string, skip: number, acc: Array<EntryT>, select?: string, refFieldsToFilterOut?: Array<string>, limit?: number) => Promise<Array<EntryT>>;

package/dist/types/impl/data/helpers/get-all-entries-recursively.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/impl/data/helpers/home-pages-by-tag-id.d.ts

@@ -0,0 +1,15 @@
+import { EntryT } from '../../../clients/contentful-client/contentful-client';
+import { ArboretumClientCtx, LocaleCodeT, SysIdT, TagIdT } from '../../arboretum-client.impl';
+import { LocalesT } from '../locales';
+export type HomePagesByTagIdT = {
+    homePagesByTagId: Map<LocaleCodeT, Map<TagIdT, Array<{
+        sys: {
+            id: SysIdT;
+        };
+    }>>>;
+    warnings?: Array<string>;
+};
+export declare const homePagesByTagId: (ctx: Pick<ArboretumClientCtx, 'localeTagIdPrefix' | 'pageHomeTagId'>, locales: LocalesT, entries: Array<{
+    metadata?: EntryT['metadata'];
+    sys: Pick<EntryT['sys'], 'id'>;
+}>) => HomePagesByTagIdT;

package/dist/types/impl/data/helpers/home-pages-by-tag-id.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/impl/data/helpers/locale-codes-from-metadata.d.ts

@@ -0,0 +1,2 @@
+import { EntryT } from '../../../clients/contentful-client/contentful-client';
+export declare const localeCodesFromMetadata: (localeTagIdPrefix: string, metadata: EntryT['metadata']) => Array<string>;

package/dist/types/impl/data/helpers/locale-codes-from-metadata.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/impl/data/helpers/parse-locale-tag.d.ts

@@ -0,0 +1,3 @@
+export declare const parseLocaleTag: (localeTagIdPrefix: string) => (tagId: string) => {
+    localeCode: string;
+} | undefined;

package/dist/types/impl/data/helpers/parse-locale-tag.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/impl/data/helpers/validate-content-types.d.ts

@@ -0,0 +1,5 @@
+import { ArboretumClientContentfulConfigOptionsT } from "../../../arboretum-client";
+import { ContentTypeT } from "../../../clients/contentful-client/contentful-client";
+import { Either } from "../../../utils/fp-utils";
+export declare const validatePageContentType: (pageContentTypeConfig: ArboretumClientContentfulConfigOptionsT["pageContentTypes"][string]) => (contentType: ContentTypeT) => Either<string, ContentTypeT>;
+export declare const validateRedirectContentType: (redirectContentTypeConfig: Pick<NonNullable<ArboretumClientContentfulConfigOptionsT["redirectContentType"]>, "pageFieldId" | "pathFieldId" | "titleFieldId" | "typeFieldId">) => (contentType: ContentTypeT) => Either<string, ContentTypeT>;

package/dist/types/impl/data/helpers/validate-content-types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/impl/data/home-page.d.ts

@@ -0,0 +1,3 @@
+import { ArboretumClientCtx } from "../arboretum-client.impl";
+import { EntryT } from "../../clients/contentful-client/contentful-client";
+export declare const homePages: (ctx: Pick<ArboretumClientCtx, "clientApi" | "localeTagIdPrefix" | "contentfulClientType">, homePageTagId: string) => Promise<Array<EntryT>>;

package/dist/types/impl/data/locales.d.ts

@@ -0,0 +1,10 @@
+import { Either } from "../../utils/fp-utils";
+import { ArboretumClientCtx, LocaleCodeT } from "../arboretum-client.impl";
+import { LocaleT } from "../../clients/contentful-client/contentful-client";
+export type LocalesT = {
+    locales: Map<LocaleCodeT, LocaleT>;
+    defaultLocaleCode: string;
+};
+type LocalesR = Either<string, LocalesT>;
+export declare const locales: (ctx: Pick<ArboretumClientCtx, "clientApi" | "options">) => Promise<LocalesR>;
+export {};

package/dist/types/impl/data/page-entries.d.ts

@@ -0,0 +1,3 @@
+import { ArboretumClientCtx } from "../arboretum-client.impl";
+import { EntriesT } from "./sitemap-data";
+export declare const pageEntries: (ctx: Pick<ArboretumClientCtx, "options" | "contentfulClientType" | "preview">, apiClient: Pick<ArboretumClientCtx["clientApi"], "getEntries">, cmaPreviewClientApi?: Pick<NonNullable<ArboretumClientCtx["cmaPreviewClientApi"]>, "getEntries">) => Promise<EntriesT>;

package/dist/types/impl/data/page-entries.test.d.ts

@@ -0,0 +1 @@
+export {};