@unchainedshop/cockpit-api 1.0.33 → 2.1.0

package/dist/fetch/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lightweight fetch client for Cockpit CMS
+ *
+ * Designed for edge/RSC environments where the full CockpitAPI is too heavy.
+ *
+ * @example
+ * ```typescript
+ * import { createFetchClient } from "@unchainedshop/cockpit-api/fetch";
+ *
+ * const cockpit = createFetchClient({
+ *   endpoint: process.env.NEXT_PUBLIC_COCKPIT_ENDPOINT,
+ *   tenant: "mytenant",
+ * });
+ *
+ * const page = await cockpit.pageByRoute("/about", { locale: "en" });
+ * ```
+ */
+export { createFetchClient } from "./client.ts";
+export type { FetchClient, FetchClientOptions, FetchCacheMode, PageFetchParams, } from "./client.ts";

package/dist/fetch/index.js

@@ -0,0 +1,18 @@
+/**
+ * Lightweight fetch client for Cockpit CMS
+ *
+ * Designed for edge/RSC environments where the full CockpitAPI is too heavy.
+ *
+ * @example
+ * ```typescript
+ * import { createFetchClient } from "@unchainedshop/cockpit-api/fetch";
+ *
+ * const cockpit = createFetchClient({
+ *   endpoint: process.env.NEXT_PUBLIC_COCKPIT_ENDPOINT,
+ *   tenant: "mytenant",
+ * });
+ *
+ * const page = await cockpit.pageByRoute("/about", { locale: "en" });
+ * ```
+ */
+export { createFetchClient } from "./client.js";

package/dist/index.d.ts

@@ -1,2 +1,28 @@
-import { CockpitAPI, getTenantIds, FixImagePaths } from "./api.js";
-export { CockpitAPI, getTenantIds, FixImagePaths };
+/**
+ * Cockpit API - TypeScript client for Cockpit CMS
+ *
+ * @packageDocumentation
+ */
+export { CockpitAPI } from "./client.ts";
+export type { CockpitAPIClient } from "./client.ts";
+export type { CockpitAPIOptions } from "./core/config.ts";
+export type { CacheManager, CacheOptions } from "./core/cache.ts";
+export { getTenantIds, resolveTenantFromUrl, resolveTenantFromSubdomain, } from "./utils/tenant.ts";
+export type { TenantUrlResult, ResolveTenantFromUrlOptions, ResolveTenantFromSubdomainOptions, } from "./utils/tenant.ts";
+export { generateCmsRouteReplacements, generateCollectionAndSingletonSlugRouteMap, } from "./utils/route-map.ts";
+export type { ResponseTransformer } from "./transformers/image-path.ts";
+export { createImagePathTransformer, identityTransformer, FixImagePaths, } from "./transformers/image-path.ts";
+export { createAssetPathTransformer, createPageLinkTransformer, composeTransformers, } from "./transformers/index.ts";
+export type { MethodContext, ListQueryOptions, ContentItemQueryOptions, ContentListQueryOptions, TreeQueryOptions, AggregateQueryOptions, } from "./methods/content.ts";
+export type { PageByIdOptions, PageByRouteOptions } from "./methods/pages.ts";
+export type { MenuQueryOptions } from "./methods/menus.ts";
+export type { SearchQueryOptions } from "./methods/search.ts";
+export type { LocalizeOptions } from "./methods/localize.ts";
+export type { CockpitContentItem, CockpitNewsItem, CockpitTreeNode, } from "./methods/content.ts";
+export { ImageSizeMode, MimeType } from "./methods/assets.ts";
+export type { CockpitAsset, ImageAssetQueryParams } from "./methods/assets.ts";
+export type { CockpitPageType, CockpitPageMeta, CockpitPageSeo, CockpitLayoutBlock, CockpitPage, } from "./methods/pages.ts";
+export type { CockpitMenuUrl, CockpitMenuLink, CockpitMenu, } from "./methods/menus.ts";
+export type { CockpitRoute, CockpitRoutesResponse, CockpitSitemapEntry, CockpitPreviewConfig, CockpitSettings, } from "./methods/routes.ts";
+export type { CockpitSearchHit, CockpitSearchResult, } from "./methods/search.ts";
+export type { CockpitHealthCheck } from "./methods/system.ts";

package/dist/index.js

@@ -1,3 +1,13 @@
-import { CockpitAPI, getTenantIds, FixImagePaths } from "./api.js";
-export { CockpitAPI, getTenantIds, FixImagePaths };
-//# sourceMappingURL=index.js.map
+/**
+ * Cockpit API - TypeScript client for Cockpit CMS
+ *
+ * @packageDocumentation
+ */
+export { CockpitAPI } from "./client.js";
+export { getTenantIds, resolveTenantFromUrl, resolveTenantFromSubdomain, } from "./utils/tenant.js";
+export { generateCmsRouteReplacements, generateCollectionAndSingletonSlugRouteMap, } from "./utils/route-map.js";
+export { createImagePathTransformer, identityTransformer, 
+// eslint-disable-next-line @typescript-eslint/no-deprecated
+FixImagePaths, } from "./transformers/image-path.js";
+export { createAssetPathTransformer, createPageLinkTransformer, composeTransformers, } from "./transformers/index.js";
+export { ImageSizeMode, MimeType } from "./methods/assets.js";

package/dist/methods/assets.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Asset API methods
+ */
+import type { MethodContext } from "./content.ts";
+export interface CockpitAsset {
+    _id: string;
+    path: string;
+    title: string;
+    mime: string;
+    type: "image" | "video" | "audio" | "document" | "archive" | "code" | "other";
+    description?: string;
+    tags?: string[];
+    size: number;
+    colors?: string[] | null;
+    width?: number | null;
+    height?: number | null;
+    _hash: string;
+    _created: number;
+    _modified: number;
+    _cby?: string;
+    _mby?: string;
+    altText?: string;
+    thumbhash?: string;
+    folder?: string;
+}
+export declare enum ImageSizeMode {
+    Thumbnail = "thumbnail",
+    BestFit = "bestFit",
+    Resize = "resize",
+    FitToWidth = "fitToWidth",
+    FitToHeight = "fitToHeight"
+}
+export declare enum MimeType {
+    AUTO = "auto",
+    GIF = "gif",
+    JPEG = "jpeg",
+    PNG = "png",
+    WEBP = "webp",
+    BMP = "bmp"
+}
+export interface ImageAssetQueryParams {
+    m?: ImageSizeMode;
+    w?: number;
+    h?: number;
+    q?: number;
+    mime?: MimeType;
+    re?: number;
+    t?: string;
+    o?: number;
+}
+export interface AssetMethods {
+    assetById<T = CockpitAsset>(assetId: string): Promise<T | null>;
+    /**
+     * Get a transformed image asset URL.
+     *
+     * **Important:** The `w` (width) or `h` (height) parameter is required by the API.
+     * Without it, the API returns a 400 error.
+     *
+     * @param assetId - The asset ID
+     * @param queryParams - Image transformation parameters (w or h required)
+     * @returns URL string to the generated image, or null if not found
+     */
+    imageAssetById(assetId: string, queryParams?: ImageAssetQueryParams): Promise<string | null>;
+}
+export declare function createAssetMethods(ctx: MethodContext): AssetMethods;

package/dist/methods/assets.js

@@ -0,0 +1,37 @@
+/**
+ * Asset API methods
+ */
+import { requireParam } from "../core/validation.js";
+export var ImageSizeMode;
+(function (ImageSizeMode) {
+    ImageSizeMode["Thumbnail"] = "thumbnail";
+    ImageSizeMode["BestFit"] = "bestFit";
+    ImageSizeMode["Resize"] = "resize";
+    ImageSizeMode["FitToWidth"] = "fitToWidth";
+    ImageSizeMode["FitToHeight"] = "fitToHeight";
+})(ImageSizeMode || (ImageSizeMode = {}));
+export var MimeType;
+(function (MimeType) {
+    MimeType["AUTO"] = "auto";
+    MimeType["GIF"] = "gif";
+    MimeType["JPEG"] = "jpeg";
+    MimeType["PNG"] = "png";
+    MimeType["WEBP"] = "webp";
+    MimeType["BMP"] = "bmp";
+})(MimeType || (MimeType = {}));
+export function createAssetMethods(ctx) {
+    return {
+        async assetById(assetId) {
+            requireParam(assetId, "assetId");
+            const url = ctx.url.build(`/assets/${assetId}`);
+            return ctx.http.fetch(url);
+        },
+        async imageAssetById(assetId, queryParams) {
+            requireParam(assetId, "assetId");
+            const url = ctx.url.build(`/assets/image/${assetId}`, {
+                queryParams: queryParams,
+            });
+            return ctx.http.fetchText(url);
+        },
+    };
+}

package/dist/methods/content.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Content API methods
+ */
+import type { HttpClient } from "../core/http.ts";
+import type { UrlBuilder } from "../core/url-builder.ts";
+import type { CacheManager } from "../core/cache.ts";
+export interface MethodContext {
+    readonly http: HttpClient;
+    readonly url: UrlBuilder;
+    readonly cache: CacheManager;
+    readonly endpoint: string;
+    readonly tenant?: string;
+}
+export interface ListQueryOptions {
+    limit?: number;
+    skip?: number;
+    sort?: Record<string, 1 | -1>;
+    filter?: Record<string, unknown>;
+    fields?: Record<string, 0 | 1>;
+    locale?: string;
+    populate?: number;
+    /** Override the client-level useAdminAccess setting for this request */
+    useAdminAccess?: boolean;
+}
+export interface ContentItemQueryOptions extends ListQueryOptions {
+    model: string;
+    id?: string;
+    queryParams?: Record<string, unknown>;
+}
+export interface ContentListQueryOptions extends ListQueryOptions {
+    queryParams?: Record<string, unknown>;
+}
+export interface TreeQueryOptions extends ListQueryOptions {
+    parent?: string;
+    queryParams?: Record<string, unknown>;
+}
+export interface AggregateQueryOptions {
+    model: string;
+    pipeline: Record<string, unknown>[];
+    locale?: string;
+}
+export interface CockpitContentItem {
+    _id: string;
+    _created?: number;
+    _modified?: number;
+    _cby?: string;
+    _mby?: string;
+    _state?: number;
+    [key: string]: unknown;
+}
+export interface CockpitNewsItem extends CockpitContentItem {
+    title: string;
+    cover?: {
+        _id: string;
+        path: string;
+        title: string;
+    };
+    author?: string;
+    publicationDate?: string;
+    content?: string;
+}
+export interface CockpitTreeNode<T = CockpitContentItem> {
+    _id: string;
+    _pid?: string;
+    _o?: number;
+    children?: CockpitTreeNode<T>[];
+    data?: T;
+}
+export interface ContentMethods {
+    getContentItem<T = unknown>(options: ContentItemQueryOptions): Promise<T | null>;
+    getContentItems<T = CockpitContentItem>(model: string, options?: ContentListQueryOptions): Promise<T[] | null>;
+    getContentTree<T = CockpitContentItem>(model: string, options?: TreeQueryOptions): Promise<CockpitTreeNode<T>[] | null>;
+    getAggregateModel<T = unknown>(options: AggregateQueryOptions): Promise<T[] | null>;
+    postContentItem<T = unknown>(model: string, item: Record<string, unknown>): Promise<T | null>;
+    deleteContentItem<T = unknown>(model: string, id: string): Promise<T | null>;
+}
+export declare function createContentMethods(ctx: MethodContext): ContentMethods;

package/dist/methods/content.js

@@ -0,0 +1,79 @@
+/**
+ * Content API methods
+ */
+import { requireParam, validatePathSegment } from "../core/validation.js";
+export function createContentMethods(ctx) {
+    const buildFetchOptions = (useAdminAccess) => useAdminAccess !== undefined ? { useAdminAccess } : {};
+    return {
+        async getContentItem(options) {
+            const { model, id, locale = "default", useAdminAccess, queryParams = {}, } = options;
+            requireParam(model, "a model");
+            validatePathSegment(model, "model");
+            if (id !== undefined)
+                validatePathSegment(id, "id");
+            const url = ctx.url.build(`/content/item/${model}${id !== undefined ? `/${id}` : ""}`, {
+                locale,
+                queryParams,
+            });
+            return ctx.http.fetch(url, buildFetchOptions(useAdminAccess));
+        },
+        async getContentItems(model, options = {}) {
+            requireParam(model, "a model");
+            validatePathSegment(model, "model");
+            const { locale = "default", limit, skip, sort, filter, fields, populate, useAdminAccess, queryParams = {}, } = options;
+            const url = ctx.url.build(`/content/items/${model}`, {
+                locale,
+                queryParams: {
+                    ...queryParams,
+                    limit,
+                    skip,
+                    sort,
+                    filter,
+                    fields,
+                    populate,
+                },
+            });
+            return ctx.http.fetch(url, buildFetchOptions(useAdminAccess));
+        },
+        async getContentTree(model, options = {}) {
+            requireParam(model, "a model");
+            validatePathSegment(model, "model");
+            const { locale = "default", parent, filter, fields, populate, useAdminAccess, queryParams = {}, } = options;
+            const url = ctx.url.build(`/content/tree/${model}`, {
+                locale,
+                queryParams: {
+                    ...queryParams,
+                    parent,
+                    filter: filter ?? {},
+                    fields,
+                    populate,
+                },
+            });
+            return ctx.http.fetch(url, buildFetchOptions(useAdminAccess));
+        },
+        async getAggregateModel(options) {
+            const { model, pipeline, locale = "default" } = options;
+            requireParam(model, "a model");
+            validatePathSegment(model, "model");
+            const url = ctx.url.build(`/content/aggregate/${model}`, {
+                locale,
+                queryParams: { pipeline },
+            });
+            return ctx.http.fetch(url);
+        },
+        async postContentItem(model, item) {
+            requireParam(model, "a model");
+            validatePathSegment(model, "model");
+            const url = ctx.url.build(`/content/item/${model}`);
+            return ctx.http.post(url, { data: item });
+        },
+        async deleteContentItem(model, id) {
+            requireParam(model, "a model");
+            requireParam(id, "an id");
+            validatePathSegment(model, "model");
+            validatePathSegment(id, "id");
+            const url = ctx.url.build(`/content/item/${model}/${id}`);
+            return ctx.http.delete(url);
+        },
+    };
+}

package/dist/methods/graphql.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GraphQL API method
+ */
+import { type DocumentNode } from "graphql";
+import type { MethodContext } from "./content.ts";
+export interface GraphQLMethods {
+    graphQL<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>): Promise<T | null>;
+}
+export declare function createGraphQLMethods(ctx: MethodContext): GraphQLMethods;

package/dist/methods/graphql.js

@@ -0,0 +1,13 @@
+/**
+ * GraphQL API method
+ */
+import { print } from "graphql";
+export function createGraphQLMethods(ctx) {
+    return {
+        async graphQL(document, variables) {
+            const query = print(document);
+            const endpoint = ctx.url.graphqlEndpoint();
+            return ctx.http.post(endpoint, { query, variables });
+        },
+    };
+}

package/dist/methods/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Method exports
+ */
+export type { MethodContext } from "./content.ts";
+export type { ContentMethods } from "./content.ts";
+export { createContentMethods } from "./content.ts";
+export type { PagesMethods, PageByRouteOptions } from "./pages.ts";
+export { createPagesMethods } from "./pages.ts";
+export type { MenuMethods } from "./menus.ts";
+export { createMenuMethods } from "./menus.ts";
+export type { RouteMethods } from "./routes.ts";
+export { createRouteMethods } from "./routes.ts";
+export type { AssetMethods } from "./assets.ts";
+export { createAssetMethods } from "./assets.ts";
+export type { GraphQLMethods } from "./graphql.ts";
+export { createGraphQLMethods } from "./graphql.ts";
+export type { SearchMethods } from "./search.ts";
+export { createSearchMethods } from "./search.ts";
+export type { LocalizeMethods } from "./localize.ts";
+export { createLocalizeMethods } from "./localize.ts";
+export type { SystemMethods } from "./system.ts";
+export { createSystemMethods } from "./system.ts";

package/dist/methods/index.js

@@ -0,0 +1,12 @@
+/**
+ * Method exports
+ */
+export { createContentMethods } from "./content.js";
+export { createPagesMethods } from "./pages.js";
+export { createMenuMethods } from "./menus.js";
+export { createRouteMethods } from "./routes.js";
+export { createAssetMethods } from "./assets.js";
+export { createGraphQLMethods } from "./graphql.js";
+export { createSearchMethods } from "./search.js";
+export { createLocalizeMethods } from "./localize.js";
+export { createSystemMethods } from "./system.js";

package/dist/methods/localize.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Localization API methods (Lokalize addon)
+ */
+import type { MethodContext } from "./content.ts";
+export interface LocalizeOptions {
+    locale?: string;
+    nested?: boolean;
+}
+export interface LocalizeMethods {
+    localize<T = unknown>(projectName: string, options?: LocalizeOptions): Promise<T | null>;
+}
+export declare function createLocalizeMethods(ctx: MethodContext): LocalizeMethods;

package/dist/methods/localize.js

@@ -0,0 +1,17 @@
+/**
+ * Localization API methods (Lokalize addon)
+ */
+import { requireParam } from "../core/validation.js";
+export function createLocalizeMethods(ctx) {
+    return {
+        async localize(projectName, options = {}) {
+            requireParam(projectName, "projectName");
+            const { locale = "default", nested = false } = options;
+            const url = ctx.url.build(`/lokalize/project/${projectName}`, {
+                locale,
+                queryParams: { nested },
+            });
+            return ctx.http.fetch(url);
+        },
+    };
+}

package/dist/methods/menus.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Menu API methods
+ */
+import type { MethodContext } from "./content.ts";
+import type { CockpitAsset } from "./assets.ts";
+export interface MenuQueryOptions {
+    inactive?: boolean;
+    locale?: string;
+}
+export interface CockpitMenuUrl {
+    route: string;
+    locale: string;
+}
+export interface CockpitMenuLink {
+    active: boolean;
+    title: string;
+    url: string | CockpitMenuUrl;
+    target?: string;
+    data?: {
+        image?: CockpitAsset | null;
+        [key: string]: unknown;
+    };
+    children?: CockpitMenuLink[];
+    meta?: {
+        key: string;
+        value: string;
+    }[];
+}
+export interface CockpitMenu {
+    _id: string;
+    name: string;
+    label: string;
+    info?: string;
+    group?: string;
+    color?: string;
+    links: CockpitMenuLink[];
+}
+export interface MenuMethods {
+    pagesMenus<T = CockpitMenu>(options?: MenuQueryOptions | string): Promise<T[] | null>;
+    pagesMenu<T = CockpitMenu>(name: string, options?: MenuQueryOptions | string): Promise<T | null>;
+}
+export declare function createMenuMethods(ctx: MethodContext): MenuMethods;

package/dist/methods/menus.js

@@ -0,0 +1,25 @@
+/**
+ * Menu API methods
+ */
+export function createMenuMethods(ctx) {
+    return {
+        async pagesMenus(options = "default") {
+            const opts = typeof options === "string" ? { locale: options } : options;
+            const { locale = "default", inactive } = opts;
+            const url = ctx.url.build("/pages/menus", {
+                locale,
+                queryParams: { inactive },
+            });
+            return ctx.http.fetch(url);
+        },
+        async pagesMenu(name, options = "default") {
+            const opts = typeof options === "string" ? { locale: options } : options;
+            const { locale = "default", inactive } = opts;
+            const url = ctx.url.build(`/pages/menu/${name}`, {
+                locale,
+                queryParams: { inactive },
+            });
+            return ctx.http.fetch(url);
+        },
+    };
+}

package/dist/methods/pages.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pages API methods
+ */
+import type { MethodContext, ContentListQueryOptions } from "./content.ts";
+import type { CockpitAsset } from "./assets.ts";
+export interface PageByIdOptions {
+    locale?: string;
+    populate?: number;
+}
+export interface PageByRouteOptions {
+    locale?: string;
+    populate?: number;
+}
+export type CockpitPageType = "layout" | "collection" | "singleton" | "link";
+export interface CockpitPageMeta {
+    _id: string;
+    title: string;
+    type: CockpitPageType;
+    slug?: string;
+    _r?: string;
+    _created?: number;
+    _modified?: number;
+}
+export interface CockpitPageSeo {
+    title?: string;
+    description?: string;
+    keywords?: string;
+    image?: CockpitAsset;
+    noindex?: boolean;
+    nofollow?: boolean;
+}
+export interface CockpitLayoutBlock {
+    component: string;
+    label?: string;
+    settings?: Record<string, unknown>;
+    children?: CockpitLayoutBlock[];
+}
+export interface CockpitPage extends CockpitPageMeta {
+    data?: Record<string, unknown>;
+    seo?: CockpitPageSeo;
+    layout?: CockpitLayoutBlock[];
+    _p?: string;
+}
+export interface PagesMethods {
+    pages<T = CockpitPage>(options?: ContentListQueryOptions): Promise<T[] | null>;
+    pageById<T = CockpitPage>(id: string, options?: PageByIdOptions): Promise<T | null>;
+    pageByRoute<T = CockpitPage>(route: string, options?: PageByRouteOptions | string): Promise<T | null>;
+}
+export declare function createPagesMethods(ctx: MethodContext): PagesMethods;

package/dist/methods/pages.js

@@ -0,0 +1,34 @@
+/**
+ * Pages API methods
+ */
+import { requireParam } from "../core/validation.js";
+export function createPagesMethods(ctx) {
+    return {
+        async pages(options = {}) {
+            const { locale = "default", limit, skip, sort, filter, fields, queryParams = {}, } = options;
+            const url = ctx.url.build("/pages/pages", {
+                locale,
+                queryParams: { ...queryParams, limit, skip, sort, filter, fields },
+            });
+            return ctx.http.fetch(url);
+        },
+        async pageById(id, options = {}) {
+            requireParam(id, "a page id");
+            const { locale = "default", populate } = options;
+            const url = ctx.url.build(`/pages/page/${id}`, {
+                locale,
+                queryParams: { populate },
+            });
+            return ctx.http.fetch(url);
+        },
+        async pageByRoute(route, options = "default") {
+            const opts = typeof options === "string" ? { locale: options } : options;
+            const { locale = "default", populate } = opts;
+            const url = ctx.url.build("/pages/page", {
+                locale,
+                queryParams: { route, populate },
+            });
+            return ctx.http.fetch(url);
+        },
+    };
+}

package/dist/methods/routes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Routes, sitemap, and settings API methods
+ */
+import type { MethodContext } from "./content.ts";
+import type { CockpitAsset } from "./assets.ts";
+import type { CockpitPageType, CockpitPageSeo } from "./pages.ts";
+export interface CockpitRoute {
+    route: string;
+    slug: string;
+    type: CockpitPageType;
+    lastmod: string;
+}
+export type CockpitRoutesResponse = Record<string, CockpitRoute[]>;
+export interface CockpitSitemapEntry {
+    routes: Record<string, string>;
+    type: CockpitPageType;
+    lastmod: string;
+}
+export interface CockpitPreviewConfig {
+    name: string;
+    uri: string;
+}
+export interface CockpitSettings {
+    revisions?: boolean;
+    meta?: Record<string, unknown>;
+    preview?: CockpitPreviewConfig[];
+    images?: {
+        logo?: CockpitAsset | null;
+        small?: CockpitAsset | null;
+        favicon?: CockpitAsset | null;
+        [key: string]: CockpitAsset | null | undefined;
+    };
+    scripts?: {
+        header?: string | null;
+        footer?: string | null;
+    };
+    seo?: CockpitPageSeo;
+    locales?: string[];
+}
+export interface RouteMethods {
+    pagesRoutes<T = CockpitRoutesResponse>(locale?: string): Promise<T | null>;
+    pagesSitemap<T = CockpitSitemapEntry>(): Promise<T[] | null>;
+    pagesSetting<T = CockpitSettings>(locale?: string): Promise<T | null>;
+    getFullRouteForSlug(slug: string): Promise<string | undefined>;
+}
+export declare function createRouteMethods(ctx: MethodContext): RouteMethods;

package/dist/methods/routes.js

@@ -0,0 +1,24 @@
+/**
+ * Routes, sitemap, and settings API methods
+ */
+import { generateCollectionAndSingletonSlugRouteMap } from "../utils/route-map.js";
+export function createRouteMethods(ctx) {
+    return {
+        async pagesRoutes(locale = "default") {
+            const url = ctx.url.build("/pages/routes", { locale });
+            return ctx.http.fetch(url);
+        },
+        async pagesSitemap() {
+            const url = ctx.url.build("/pages/sitemap");
+            return ctx.http.fetch(url);
+        },
+        async pagesSetting(locale = "default") {
+            const url = ctx.url.build("/pages/settings", { locale });
+            return ctx.http.fetch(url);
+        },
+        async getFullRouteForSlug(slug) {
+            const routeSlugMap = await generateCollectionAndSingletonSlugRouteMap(ctx.endpoint, ctx.tenant, ctx.cache);
+            return routeSlugMap[slug];
+        },
+    };
+}