@sitecore-jss/sitecore-jss 0.1.0-beta.2

package/types/site/graphql-redirects-service.d.ts

@@ -0,0 +1,66 @@
+import { GraphQLClient } from '../graphql';
+import { CacheOptions, CacheClient } from '../cache-client';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export declare const REDIRECT_TYPE_301 = "REDIRECT_301";
+export declare const REDIRECT_TYPE_302 = "REDIRECT_302";
+export declare const REDIRECT_TYPE_SERVER_TRANSFER = "SERVER_TRANSFER";
+export declare type RedirectInfo = {
+    pattern: string;
+    target: string;
+    redirectType: string;
+    isQueryStringPreserved: boolean;
+    locale: string;
+};
+export declare type GraphQLRedirectsServiceConfig = CacheOptions & {
+    /**
+     * Override fetch method. Uses 'GraphQLRequestClient' default otherwise.
+     */
+    fetch?: typeof fetch;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * The schema of data returned in response to redirects array request
+ */
+export declare type RedirectsQueryResult = {
+    site: {
+        siteInfo: {
+            redirects: RedirectInfo[];
+        } | null;
+    };
+};
+/**
+ *  The GraphQLRedirectsService class is used to query the JSS redirects using Graphql endpoint
+ */
+export declare class GraphQLRedirectsService {
+    private options;
+    private graphQLClient;
+    private cache;
+    protected get query(): string;
+    /**
+     * Creates an instance of graphQL redirects service with the provided options
+     * @param {GraphQLRedirectsServiceConfig} options instance
+     */
+    constructor(options: GraphQLRedirectsServiceConfig);
+    /**
+     * Fetch an array of redirects from API
+     * @param {string} siteName site name
+     * @returns Promise<RedirectInfo[]>
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchRedirects(siteName: string): Promise<RedirectInfo[]>;
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    protected getCacheClient(): CacheClient<RedirectsQueryResult>;
+}

package/types/site/graphql-robots-service.d.ts

@@ -0,0 +1,47 @@
+import { GraphQLClient } from '../graphql';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export declare type GraphQLRobotsServiceConfig = {
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * The schema of data returned in response to robots.txt request
+ */
+export declare type RobotsQueryResult = {
+    site: {
+        siteInfo: {
+            robots: string;
+        };
+    };
+};
+/**
+ * Service that fetch the robots.txt data using Sitecore's GraphQL API.
+ */
+export declare class GraphQLRobotsService {
+    options: GraphQLRobotsServiceConfig;
+    private graphQLClient;
+    protected get query(): string;
+    /**
+     * Creates an instance of graphQL robots.txt service with the provided options
+     * @param {GraphQLRobotsServiceConfig} options instance
+     */
+    constructor(options: GraphQLRobotsServiceConfig);
+    /**
+     * Fetch a data of robots.txt from API
+     * @returns text of robots.txt
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchRobots(): Promise<string>;
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/site/graphql-siteinfo-service.d.ts

@@ -0,0 +1,69 @@
+import { GraphQLClient } from '../graphql';
+import { CacheClient, CacheOptions } from '../cache-client';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export declare type SiteInfo = {
+    /**
+     * Additional user-defined properties
+     */
+    [key: string]: unknown;
+    /**
+     * Site name
+     */
+    name: string;
+    /**
+     * Site host name. May include multiple values (separated by '|') and wildcards ('*')
+     */
+    hostName: string;
+    /**
+     * Site default language
+     */
+    language: string;
+};
+export declare type GraphQLSiteInfoServiceConfig = CacheOptions & {
+    /** common variable for all GraphQL queries
+     * it will be used for every type of query to regulate result batch size
+     * Optional. How many result items to fetch in each GraphQL call. This is needed for pagination.
+     * @default 10
+     */
+    pageSize?: number;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+export declare type GraphQLSiteInfoResult = {
+    name: {
+        value: string;
+    };
+    hostName: {
+        value: string;
+    };
+    language: {
+        value: string;
+    };
+};
+export declare class GraphQLSiteInfoService {
+    private config;
+    private graphQLClient;
+    private cache;
+    protected get query(): string;
+    /**
+     * Creates an instance of graphQL service to retrieve site configuration list from Sitecore
+     * @param {GraphQLSiteInfoServiceConfig} config instance
+     */
+    constructor(config: GraphQLSiteInfoServiceConfig);
+    fetchSiteInfo(): Promise<SiteInfo[]>;
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    protected getCacheClient(): CacheClient<SiteInfo[]>;
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+    private getCacheKey;
+}

package/types/site/graphql-sitemap-service.d.ts

@@ -0,0 +1,53 @@
+import { GraphQLClient } from '../graphql';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export declare type GraphQLSitemapXmlServiceConfig = {
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * The schema of data returned in response to sitemaps request
+ */
+export declare type SitemapQueryResult = {
+    site: {
+        siteInfo: {
+            sitemap: string[];
+        };
+    };
+};
+/**
+ * Service that fetch the sitemaps data using Sitecore's GraphQL API.
+ */
+export declare class GraphQLSitemapXmlService {
+    options: GraphQLSitemapXmlServiceConfig;
+    private graphQLClient;
+    protected get query(): string;
+    /**
+     * Creates an instance of graphQL sitemaps service with the provided options
+     * @param {GraphQLSitemapXmlServiceConfig} options instance
+     */
+    constructor(options: GraphQLSitemapXmlServiceConfig);
+    /**
+     * Fetch list of sitemaps for the site
+     * @returns {string[]} list of sitemap paths
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchSitemaps(): Promise<string[]>;
+    /**
+     * Get sitemap file path for sitemap id
+     * @param {string} id the sitemap id (can be empty for default 'sitemap.xml' file)
+     * @returns {string | undefined} the sitemap file path or undefined if one doesn't exist
+     */
+    getSitemap(id: string): Promise<string | undefined>;
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/site/index.d.ts

@@ -0,0 +1,7 @@
+export { RobotsQueryResult, GraphQLRobotsService, GraphQLRobotsServiceConfig, } from './graphql-robots-service';
+export { RedirectInfo, RedirectsQueryResult, REDIRECT_TYPE_301, REDIRECT_TYPE_302, REDIRECT_TYPE_SERVER_TRANSFER, GraphQLRedirectsService, GraphQLRedirectsServiceConfig, } from './graphql-redirects-service';
+export { SitemapQueryResult, GraphQLSitemapXmlService, GraphQLSitemapXmlServiceConfig, } from './graphql-sitemap-service';
+export { ErrorPages, GraphQLErrorPagesService, GraphQLErrorPagesServiceConfig, } from './graphql-error-pages-service';
+export { SiteInfo, GraphQLSiteInfoService, GraphQLSiteInfoServiceConfig, } from './graphql-siteinfo-service';
+export { getSiteRewrite, getSiteRewriteData, normalizeSiteRewrite, SiteRewriteData } from './utils';
+export { SiteResolver } from './site-resolver';

package/types/site/site-resolver.d.ts

@@ -0,0 +1,27 @@
+import { SiteInfo } from './graphql-siteinfo-service';
+/**
+ * Resolves site based on the provided host or site name
+ */
+export declare class SiteResolver {
+    readonly sites: SiteInfo[];
+    /**
+     * @param {SiteInfo[]} sites Array of sites to be used in resolution
+     */
+    constructor(sites: SiteInfo[]);
+    /**
+     * Resolve site by host name
+     * @param {string} hostName the host name
+     * @returns {SiteInfo} the resolved site
+     * @throws {Error} if a matching site is not found
+     */
+    getByHost: (hostName: string) => SiteInfo;
+    /**
+     * Resolve site by site name
+     * @param {string} siteName the site name
+     * @returns {SiteInfo} the resolved site
+     * @throws {Error} if a matching site is not found
+     */
+    getByName: (siteName: string) => SiteInfo;
+    protected getHostMap: () => Map<string, SiteInfo>;
+    protected matchesPattern(hostname: string, pattern: string): boolean;
+}

package/types/site/utils.d.ts

@@ -0,0 +1,24 @@
+export declare const SITE_PREFIX = "_site_";
+export declare type SiteRewriteData = {
+    siteName: string;
+};
+/**
+ * Get a site rewrite path for given pathname
+ * @param {string} pathname the pathname
+ * @param {SiteRewriteData} data the site data to include in the rewrite
+ * @returns {string} the rewrite path
+ */
+export declare function getSiteRewrite(pathname: string, data: SiteRewriteData): string;
+/**
+ * Get site data from the rewrite path
+ * @param {string} pathname the pathname
+ * @param {string} defaultSiteName the default site name
+ * @returns {SiteRewriteData} the site data from the rewrite
+ */
+export declare function getSiteRewriteData(pathname: string, defaultSiteName: string): SiteRewriteData;
+/**
+ * Normalize a site rewrite path (remove site data)
+ * @param {string} pathname the pathname
+ * @returns {string} the pathname with site data removed
+ */
+export declare function normalizeSiteRewrite(pathname: string): string;

package/types/utils/edit-frame.d.ts

@@ -0,0 +1,76 @@
+export declare type ChromeCommand = {
+    isDivider: boolean;
+    click: string;
+    header: string;
+    icon: string;
+    tooltip: string | null;
+    type: string | null;
+};
+export declare const DefaultEditFrameButtonIds: {
+    edit: string;
+};
+export declare const DefaultEditFrameButton: {
+    insert: {
+        header: string;
+        icon: string;
+        click: string;
+        tooltip: string;
+    };
+    editRelatedItem: {
+        header: string;
+        icon: string;
+        click: string;
+        tooltip: string;
+    };
+    edit: {
+        header: string;
+        icon: string;
+        fields: string[];
+        tooltip: string;
+    };
+};
+export declare const DefaultEditFrameButtons: ({
+    header: string;
+    icon: string;
+    click: string;
+    tooltip: string;
+} | {
+    header: string;
+    icon: string;
+    fields: string[];
+    tooltip: string;
+})[];
+export declare type EditFrameDataSource = {
+    itemId: string;
+    databaseName?: string;
+    language?: string;
+};
+export declare type BaseEditButton = {
+    isDivider?: boolean;
+    header?: string;
+    icon?: string;
+    tooltip?: string;
+};
+export declare type FieldEditButton = BaseEditButton & {
+    fields: string[];
+};
+export declare type WebEditButton = BaseEditButton & {
+    click: string;
+    parameters?: Record<string, string | number | boolean | undefined | null>;
+    type?: string;
+};
+export declare type EditButtonTypes = WebEditButton | FieldEditButton | '|';
+/**
+ * Map the edit button types to chrome data
+ * @param {EditButtonTypes } button the edit button to build a ChromeCommand for
+ * @param {string} itemId the ID of the item the EditFrame is associated with
+ * @param {Record<string, string | number | boolean | undefined | null>} frameParameters additional parameters passed to the EditFrame
+ */
+export declare function mapButtonToCommand(button: EditButtonTypes, itemId?: string, frameParameters?: Record<string, string | number | boolean | undefined | null>): ChromeCommand;
+/**
+ * Build a ChromeCommand from a web edit button. Merging the parameters from the button, frame and id
+ * @param {WebEditButton } button the web edit button to build a ChromeCommand for
+ * @param {string} itemId the ID of the item the EditFrame is associated with
+ * @param {Record<string, string>} frameParameters additional parameters passed to the EditFrame
+ */
+export declare function commandBuilder(button: WebEditButton, itemId?: string, frameParameters?: Record<string, string | number | boolean | undefined | null>): ChromeCommand;

package/types/utils/editing.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Application metadata
+ */
+export interface Metadata {
+    packages: {
+        [key: string]: string;
+    };
+}
+/**
+ * Static utility class for Sitecore Experience Editor
+ */
+export declare class ExperienceEditor {
+    /**
+     * Determines whether the current execution context is within a Experience Editor.
+     * Experience Editor environment can be identified only in the browser
+     * @returns true if executing within a Experience Editor
+     */
+    static isActive(): boolean;
+    static resetChromes(): void;
+}
+/**
+ * Copy of chrome rediscovery contract from Horizon (chrome-rediscovery.contract.ts)
+ */
+export declare const ChromeRediscoveryGlobalFunctionName: {
+    name: string;
+};
+/**
+ * Static utility class for Sitecore Horizon Editor
+ */
+export declare class HorizonEditor {
+    /**
+     * Determines whether the current execution context is within a Horizon Editor.
+     * Horizon Editor environment can be identified only in the browser
+     * @returns true if executing within a Horizon Editor
+     */
+    static isActive(): boolean;
+    static resetChromes(): void;
+}
+/**
+ * Determines whether the current execution context is within a Sitecore editor.
+ * Sitecore Editor environment can be identified only in the browser
+ * @returns true if executing within a Sitecore editor
+ */
+export declare const isEditorActive: () => boolean;
+/**
+ * Resets Sitecore editor "chromes"
+ */
+export declare const resetEditorChromes: () => void;
+/**
+ * @description in Experience Editor, anchor tags
+ * with both onclick and href attributes will use the href, blocking the onclick from firing.
+ * This function makes it so the anchor tags function as intended in the sample when using Experience Editor
+ *
+ * The Mutation Observer API is used to observe changes to the body, then select all elements with href="#" and an onclick,
+ * and replaces the # value with javascript:void(0); which prevents the anchor tag from blocking the onclick event handler.
+ * @see Mutation Observer API: https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver/MutationObserver
+ */
+export declare const handleEditorAnchors: () => void;

package/types/utils/env.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Method to parse JSON-formatted environment variables
+ * @param {string} envValue - can be undefined when providing values via process.env
+ * @param {T} defaultValue - default value
+ * @returns {T | string} parsed value
+ */
+export declare const tryParseEnvValue: <T>(envValue: string | undefined, defaultValue: T) => T;

package/types/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { default as isServer } from './is-server';
+export { resolveUrl, isAbsoluteUrl, isTimeoutError } from './utils';
+export { tryParseEnvValue } from './env';
+export { ExperienceEditor, HorizonEditor, isEditorActive, resetEditorChromes, handleEditorAnchors, Metadata, } from './editing';
+export { DefaultEditFrameButton, DefaultEditFrameButtons, DefaultEditFrameButtonIds, EditFrameDataSource, ChromeCommand, FieldEditButton, WebEditButton, EditButtonTypes, mapButtonToCommand, } from './edit-frame';

package/types/utils/is-server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines whether the current execution context is server-side
+ * @returns true if executing server-side
+ */
+declare function isServer(): boolean;
+export default isServer;

package/types/utils/timeout-promise.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/**
+ * A helper to assign timeouts to fetch or other promises
+ * Useful in nextjs middleware until fetch.signal is fully supported by Vercel edge functions
+ */
+export default class TimeoutPromise {
+    private timeout;
+    timeoutId: NodeJS.Timeout | undefined;
+    constructor(timeout: number);
+    /**
+     * Creates a timeout promise
+     */
+    get start(): Promise<unknown>;
+    /**
+     * Clears the timeout from timeout promise
+     */
+    clear(): void;
+}

package/types/utils/utils.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { ParsedUrlQueryInput } from 'querystring';
+/**
+ * Resolves a base URL that may contain query string parameters and an additional set of query
+ * string parameters into a unified string representation.
+ * @param {string} urlBase the base URL that may contain query string parameters
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns a URL string
+ * @throws {RangeError} if the provided url is an empty string
+ */
+export declare function resolveUrl(urlBase: string, params?: ParsedUrlQueryInput): string;
+export declare const isAbsoluteUrl: (url: string) => boolean;
+/**
+ * Indicates whether the error is a timeout error
+ * @param {unknown} error error
+ * @returns {boolean} is timeout error
+ */
+export declare const isTimeoutError: (error: unknown) => boolean;

package/utils.d.ts

@@ -0,0 +1 @@
+export * from './types/utils/index';

package/utils.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/utils/index');