@commercetools-frontend/application-shell 0.0.0-CRAFT-1791-20251006162610

package/dist/declarations/src/utils/get-previous-project-key/get-previous-project-key.d.ts

@@ -0,0 +1,2 @@
+declare const getPreviousProjectKey: (defaultProjectKeyOfUser?: string) => string | undefined;
+export default getPreviousProjectKey;

package/dist/declarations/src/utils/get-previous-project-key/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./get-previous-project-key.js";

package/dist/declarations/src/utils/oidc.d.ts

@@ -0,0 +1,10 @@
+import type { ApplicationOidcForDevelopmentConfig } from '@commercetools-frontend/constants';
+type BuilOidcScopeOptions = {
+    projectKey?: ApplicationOidcForDevelopmentConfig['initialProjectKey'];
+    oAuthScopes?: ApplicationOidcForDevelopmentConfig['oAuthScopes'];
+    additionalOAuthScopes?: ApplicationOidcForDevelopmentConfig['additionalOAuthScopes'];
+    teamId?: ApplicationOidcForDevelopmentConfig['teamId'];
+    applicationId?: ApplicationOidcForDevelopmentConfig['applicationId'];
+};
+declare const buildOidcScope: (options: BuilOidcScopeOptions) => string;
+export { buildOidcScope };

package/dist/declarations/src/utils/setup-global-error-listener/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./setup-global-error-listener.js";

package/dist/declarations/src/utils/setup-global-error-listener/setup-global-error-listener.d.ts

@@ -0,0 +1 @@
+export default function setupGlobalErrorListener(): void;

package/dist/declarations/src/version.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "__@APPLICATION_KIT_PACKAGE/VERSION_OF_RELEASE__";
+export default _default;

package/dist/declarations-connectors/dist/commercetools-frontend-application-shell-connectors.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../src/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWVyY2V0b29scy1mcm9udGVuZC1hcHBsaWNhdGlvbi1zaGVsbC1jb25uZWN0b3JzLmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIn0=

package/dist/declarations-connectors/src/components/application-context/application-context.d.ts

@@ -0,0 +1,109 @@
+import { ComponentType, ReactNode } from 'react';
+import type { ApplicationWindow } from '@commercetools-frontend/constants';
+import type { TFetchLoggedInUserQuery, TFetchProjectQuery, TIdTokenUserInfo } from "../../types/generated/mc.js";
+type TFetchedUser = TFetchLoggedInUserQuery['user'];
+type TFetchedProject = TFetchProjectQuery['project'];
+type TApplicationContextPermissions = {
+    [key: string]: boolean;
+};
+type TActionRight = {
+    [key: string]: boolean;
+};
+type TApplicationContextActionRights = {
+    [key: string]: TActionRight;
+};
+type TApplicationContextGroupedByPermission = {
+    [key: string]: {
+        values: string[];
+    } | null;
+};
+type TApplicationContextGroupedByResourceType = {
+    [key: string]: TApplicationContextGroupedByPermission | null;
+};
+/**
+ * dataFence: {
+ *   store: {
+ *     orders: {
+ *       canManageOrders: { values: ['usa', 'germany'] },
+ *       canViewOrders: { values: ['canada'] },
+ *     }
+ *   }
+ * }
+ */
+type TApplicationContextDataFenceType = 'store';
+type TApplicationContextDataFences = Partial<Record<TApplicationContextDataFenceType, TApplicationContextGroupedByResourceType>>;
+type TApplicationContextEnvironment = ApplicationWindow['app'];
+type TApplicationContextUser = Pick<NonNullable<TFetchedUser>, 'id' | 'email' | 'createdAt' | 'firstName' | 'lastName' | 'businessRole' | 'projects'> & {
+    locale: string;
+    timeZone: string;
+    idTokenUserInfo?: Omit<TIdTokenUserInfo, 'additionalClaims'> & {
+        additionalClaims: Record<string, unknown>;
+    };
+};
+declare const Context: import("react").Context<{}>;
+export declare const mapUserToApplicationContextUser: (user?: TFetchedUser) => TApplicationContextUser | null;
+export declare const mapEnvironmentToApplicationContextEnvironment: <AdditionalEnvironmentProperties extends {}>(environment: AdditionalEnvironmentProperties & TApplicationContextEnvironment, origin?: string) => AdditionalEnvironmentProperties & {
+    mcApiUrl: string;
+    applicationId: string;
+    applicationIdentifier: string;
+    applicationName: string;
+    entryPointUriPath: string;
+    customViewId?: string;
+    revision: string;
+    env: string;
+    location: string;
+    cdnUrl: string;
+    frontendHost: string;
+    servedByProxy: boolean;
+    ldClientSideId?: string;
+    trackingSentry?: string;
+    __DEVELOPMENT__?: import("@commercetools-frontend/constants").ApplicationRuntimeEnvironmentForDevelopment;
+};
+export declare const mapProjectToApplicationContextProject: (project?: TFetchedProject) => {
+    key: string;
+    version: number | null | undefined;
+    name: string;
+    countries: string[];
+    currencies: string[];
+    languages: string[];
+    ownerId: string;
+    ownerName: string;
+    sampleDataImportDataset: string | null | undefined;
+    isUserAdminOfCurrentProject: boolean | null | undefined;
+    isProductionProject: boolean;
+} | null;
+export type TApplicationContext<AdditionalEnvironmentProperties extends {}> = {
+    environment: AdditionalEnvironmentProperties & TApplicationContextEnvironment;
+    user: ReturnType<typeof mapUserToApplicationContextUser>;
+    project: ReturnType<typeof mapProjectToApplicationContextProject>;
+    permissions: TApplicationContextPermissions | null;
+    actionRights: TApplicationContextActionRights | null;
+    dataFences: TApplicationContextDataFences | null;
+    dataLocale: string | null;
+};
+export type ProviderProps<AdditionalEnvironmentProperties extends {}> = {
+    environment: AdditionalEnvironmentProperties & TApplicationContextEnvironment;
+    user?: TFetchedUser;
+    project?: TFetchedProject;
+    projectDataLocale?: string;
+    children: ReactNode;
+};
+type ConsumerProps<AdditionalEnvironmentProperties extends {}> = {
+    render: (context: TApplicationContext<AdditionalEnvironmentProperties>) => ReactNode;
+    children?: never;
+};
+declare const ApplicationContextProvider: {
+    <AdditionalEnvironmentProperties extends {}>(props: ProviderProps<AdditionalEnvironmentProperties>): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const ApplicationContext: {
+    <AdditionalEnvironmentProperties extends {}>(props: ConsumerProps<AdditionalEnvironmentProperties>): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare function withApplicationContext<OwnProps extends {}, AdditionalEnvironmentProperties extends {}, MappedProps extends {} = {
+    applicationContext?: TApplicationContext<AdditionalEnvironmentProperties>;
+}>(mapApplicationContextToProps?: (context: TApplicationContext<AdditionalEnvironmentProperties>) => MappedProps): (Component: ComponentType<OwnProps>) => ComponentType<OwnProps & MappedProps>;
+declare function useApplicationContextHook<AdditionalEnvironmentProperties extends {} = {}>(): TApplicationContext<AdditionalEnvironmentProperties>;
+declare function useApplicationContextHook<SelectedContext, AdditionalEnvironmentProperties extends {} = {}>(selector: (context: TApplicationContext<AdditionalEnvironmentProperties>) => SelectedContext): SelectedContext;
+declare const useApplicationContext: typeof useApplicationContextHook;
+export { Context, ApplicationContext, ApplicationContextProvider, withApplicationContext, useApplicationContext, };

package/dist/declarations-connectors/src/components/application-context/index.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderProps, TApplicationContext as ApplicationContext } from "./application-context.js";
+import type { TMenuVisibilities as NormalizedMenuVisibilities, TPermissions as NormalizedPermissions, TActionRights as NormalizedActionRights, TDataFences as NormalizedDataFences } from "./normalizers.js";
+export type TProviderProps<AdditionalEnvironmentProperties extends {}> = ProviderProps<AdditionalEnvironmentProperties>;
+export type TApplicationContext<AdditionalEnvironmentProperties extends {}> = ApplicationContext<AdditionalEnvironmentProperties>;
+export type TNormalizedMenuVisibilities = NormalizedMenuVisibilities;
+export type TNormalizedPermissions = NormalizedPermissions;
+export type TNormalizedActionRights = NormalizedActionRights;
+export type TNormalizedDataFences = NormalizedDataFences;
+export { Context, ApplicationContext, ApplicationContextProvider, withApplicationContext, useApplicationContext, } from "./application-context.js";
+export { normalizeAllAppliedActionRights, normalizeAllAppliedDataFences, normalizeAllAppliedMenuVisibilities, normalizeAllAppliedPermissions, } from "./normalizers.js";

package/dist/declarations-connectors/src/components/application-context/normalizers.d.ts

@@ -0,0 +1,48 @@
+import type { TAppliedPermission, TAppliedActionRight, TAppliedMenuVisibilities, TStoreDataFence } from "../../types/generated/mc.js";
+export type TMenuVisibilities = {
+    [key: string]: boolean;
+};
+export type TPermissions = {
+    [key: string]: boolean;
+};
+export type TActionRight = {
+    [key: string]: boolean;
+};
+export type TActionRights = {
+    [key: string]: TActionRight;
+};
+export type TDataFenceGroupedByPermission = {
+    [key: string]: {
+        values: string[];
+    } | null;
+};
+export type TDataFenceGroupedByResourceType = {
+    [key: string]: TDataFenceGroupedByPermission | null;
+};
+export type TDataFenceStoresGroupByResourceType = {
+    [key: string]: TStoreDataFence[];
+};
+export type TDataFenceType = 'store';
+export type TDataFences = Partial<Record<TDataFenceType, TDataFenceGroupedByResourceType>>;
+/**
+ * NOTE:
+ *
+ * Permissions and menu visibilities are being fetched though the `allAppliedPermissions`
+ * and the `allAppliedMenuVisibilities` which both return an array of `{ name: string, value: boolean }`.
+ * This gives more flexibility to introduce new values to apps without having to release
+ * the merchant-center-app-kit by adding/exposing them from the mc-be (our proxy service).
+ *
+ * The application below however expects both permissions an menu visibilities to be of the shape
+ * `[name: string]: boolean` which is what the shape above is mapped into here. This object shape is easier
+ * to work with in application level code (while be a non breaking change to other packages) as you can just
+ * do `canViewProducts`.
+ *
+ * This function considering its concern belongs into the `permissions` package. However,
+ * for now it doesn't have to be shared and as a result can be co-located with
+ * the fetching logic. Given this mapping needs to be used elsewere feel free
+ * to move this over to `permissions` and export it there.
+ */
+export declare const normalizeAllAppliedPermissions: (allAppliedPermissions?: TAppliedPermission[]) => TPermissions | null;
+export declare const normalizeAllAppliedMenuVisibilities: (allAppliedMenuVisibilities?: TAppliedMenuVisibilities[]) => TMenuVisibilities | null;
+export declare const normalizeAllAppliedActionRights: (allAppliedActionRights?: TAppliedActionRight[]) => TActionRights | null;
+export declare const normalizeAllAppliedDataFences: (allAppliedDataFences?: TStoreDataFence[]) => TDataFences | null;

package/dist/declarations-connectors/src/components/custom-view-context/custom-view-context.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+import type { CustomViewData } from '@commercetools-frontend/constants';
+import { type TApplicationContext } from "../application-context/index.js";
+export type TCustomViewContext = {
+    hostUrl: string;
+    customViewConfig: CustomViewData;
+};
+export type TMergedContext = TApplicationContext<{}> & TCustomViewContext;
+export type TCustomViewContextProviderProps = {
+    hostUrl: string;
+    customViewConfig: CustomViewData;
+    children: ReactNode;
+};
+declare const Context: import("react").Context<{}>;
+declare const CustomViewContextProvider: (props: TCustomViewContextProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+declare function useCustomViewContextHook(): TMergedContext;
+declare function useCustomViewContextHook<SelectedContext>(selector: (context: TMergedContext) => SelectedContext): SelectedContext;
+declare const useCustomViewContext: typeof useCustomViewContextHook;
+export { Context, CustomViewContextProvider, useCustomViewContext };

package/dist/declarations-connectors/src/components/custom-view-context/index.d.ts

@@ -0,0 +1,4 @@
+import type { TCustomViewContextProviderProps as CustomViewContextProviderProps, TCustomViewContext as CustomViewContext } from "./custom-view-context.js";
+export type TCustomViewContextProviderProps = CustomViewContextProviderProps;
+export type TCustomViewContext = CustomViewContext;
+export { CustomViewContextProvider, useCustomViewContext, } from "./custom-view-context.js";

package/dist/declarations-connectors/src/components/project-extension-image-regex/index.d.ts

@@ -0,0 +1,3 @@
+import type { TImageRegexContext as ImageRegexContext } from "./project-extension-image-regex.js";
+export type TImageRegexContext = ImageRegexContext;
+export { GetProjectExtensionImageRegex, ProjectExtensionProviderForImageRegex, withProjectExtensionImageRegex, useProjectExtensionImageRegex, } from "./project-extension-image-regex.js";

package/dist/declarations-connectors/src/components/project-extension-image-regex/project-extension-image-regex.d.ts

@@ -0,0 +1,37 @@
+import { type ComponentType, type ReactNode } from 'react';
+import type { TImageRegexOptions } from "../../types/generated/settings.js";
+export type TImageRegexContext = {
+    isLoading: boolean;
+    imageRegex?: {
+        small?: Pick<TImageRegexOptions, 'flag' | 'replace' | 'search'> | null;
+        thumb?: Pick<TImageRegexOptions, 'flag' | 'replace' | 'search'> | null;
+    } | null;
+};
+type ProviderProps = {
+    skip?: boolean;
+    children: ReactNode;
+};
+type ConsumerProps = {
+    render: (imageRegex: TImageRegexContext) => ReactNode;
+    children?: never;
+};
+declare const useProjectExtensionImageRegex: () => {
+    isLoading: boolean;
+    imageRegex: {
+        small?: Pick<TImageRegexOptions, "flag" | "replace" | "search"> | null;
+        thumb?: Pick<TImageRegexOptions, "flag" | "replace" | "search"> | null;
+    } | null | undefined;
+};
+declare const ProjectExtensionProviderForImageRegex: {
+    (props: ProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const GetProjectExtensionImageRegex: {
+    (props: ConsumerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare function withProjectExtensionImageRegex<Props extends {}>(propKey?: string): (Component: ComponentType<Props>) => {
+    (props: Props): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { GetProjectExtensionImageRegex, ProjectExtensionProviderForImageRegex, withProjectExtensionImageRegex, useProjectExtensionImageRegex, };

package/dist/declarations-connectors/src/configure-apollo.d.ts

@@ -0,0 +1,7 @@
+import { type NormalizedCacheObject, type InMemoryCacheConfig, ApolloClient, ApolloLink } from '@apollo/client';
+type TApolloClientOptions = {
+    cache?: InMemoryCacheConfig;
+    restLink?: ApolloLink;
+};
+declare const createApolloClient: (options?: TApolloClientOptions) => ApolloClient<NormalizedCacheObject>;
+export default createApolloClient;

package/dist/declarations-connectors/src/export-types.d.ts

@@ -0,0 +1,21 @@
+import type { TProviderProps as ProviderProps, TApplicationContext as ApplicationContext, TNormalizedMenuVisibilities as NormalizedMenuVisibilities, TNormalizedPermissions as NormalizedPermissions, TNormalizedActionRights as NormalizedActionRights, TNormalizedDataFences as NormalizedDataFences } from "./components/application-context/index.js";
+import type { TCustomViewContextProviderProps as CustomViewContextProviderProps, TCustomViewContext as CustomViewContext } from "./components/custom-view-context/index.js";
+import type { TImageRegexContext as ImageRegexContext } from "./components/project-extension-image-regex/index.js";
+import type { TApolloContext as ApolloContext } from "./utils/apollo-context.js";
+import type { TFetcher, TFetcherResponse, THeaders, TConfig, TOptions, TForwardToAudiencePolicy as ForwardToAudiencePolicy } from "./utils/http-client.js";
+export type TProviderProps<AdditionalEnvironmentProperties extends {}> = ProviderProps<AdditionalEnvironmentProperties>;
+export type TApplicationContext<AdditionalEnvironmentProperties extends {}> = ApplicationContext<AdditionalEnvironmentProperties>;
+export type TNormalizedMenuVisibilities = NormalizedMenuVisibilities;
+export type TNormalizedPermissions = NormalizedPermissions;
+export type TNormalizedActionRights = NormalizedActionRights;
+export type TNormalizedDataFences = NormalizedDataFences;
+export type TCustomViewContextProviderProps = CustomViewContextProviderProps;
+export type TCustomViewContext = CustomViewContext;
+export type TImageRegexContext = ImageRegexContext;
+export type TApolloContext = ApolloContext;
+export type TForwardToAudiencePolicy = ForwardToAudiencePolicy;
+export type THttpClientFetcher<Data> = TFetcher<Data>;
+export type THttpClientFetcherResponse<Data> = TFetcherResponse<Data>;
+export type THttpClientHeaders = THeaders;
+export type THttpClientConfig = TConfig;
+export type THttpClientOptions = TOptions;

package/dist/declarations-connectors/src/hooks/apollo-hooks/apollo-hooks.d.ts

@@ -0,0 +1,12 @@
+import type { OperationVariables, QueryResult, QueryHookOptions, QueryTuple, MutationTuple, MutationHookOptions, TypedDocumentNode, DocumentNode } from '@apollo/client';
+import type { TApolloContext } from "../../utils/apollo-context.js";
+type TQueryOptionsWithContext<TData = unknown, TVariables extends OperationVariables = OperationVariables> = QueryHookOptions<TData, TVariables> & {
+    context: TApolloContext;
+};
+type TMutationOptionsWithContext<TData = unknown, TVariables = OperationVariables> = MutationHookOptions<TData, TVariables, TApolloContext> & {
+    context: TApolloContext;
+};
+declare function useMcQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: TQueryOptionsWithContext<TData, TVariables>): QueryResult<TData, TVariables>;
+declare function useMcLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: TQueryOptionsWithContext<TData, TVariables>): QueryTuple<TData, TVariables>;
+declare function useMcMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: TMutationOptionsWithContext<TData, TVariables>): MutationTuple<TData, TVariables, TApolloContext>;
+export { useMcQuery, useMcLazyQuery, useMcMutation };

package/dist/declarations-connectors/src/hooks/apollo-hooks/index.d.ts

@@ -0,0 +1 @@
+export * from "./apollo-hooks.js";

package/dist/declarations-connectors/src/hooks/custom-views/use-custom-view-parent-data-refresher.d.ts

@@ -0,0 +1,5 @@
+export type TCustomViewParentDataRefresherParams = {
+    locators: string[];
+    onRefreshDataRequested: (context: Record<string, unknown>) => void;
+};
+export declare const useCustomViewParentDataRefresher: (params: TCustomViewParentDataRefresherParams) => void;

package/dist/declarations-connectors/src/index.d.ts

@@ -0,0 +1,12 @@
+export { default as version } from "./version.js";
+export * from "./export-types.js";
+export { Context, ApplicationContext, ApplicationContextProvider, withApplicationContext, useApplicationContext, normalizeAllAppliedActionRights, normalizeAllAppliedDataFences, normalizeAllAppliedMenuVisibilities, normalizeAllAppliedPermissions, } from "./components/application-context/index.js";
+export { useCustomViewParentDataRefresher } from "./hooks/custom-views/use-custom-view-parent-data-refresher.js";
+export { CustomViewContextProvider, useCustomViewContext, } from "./components/custom-view-context/index.js";
+export { GetProjectExtensionImageRegex, ProjectExtensionProviderForImageRegex, withProjectExtensionImageRegex, useProjectExtensionImageRegex, } from "./components/project-extension-image-regex/index.js";
+export { default as createApolloClient } from "./configure-apollo.js";
+export { getCorrelationId, getMcApiUrl, isLoggerEnabled, logger, selectUserId, selectProjectKeyFromUrl, selectTeamIdFromStorage, createApolloContextForProxyForwardTo, } from "./utils/index.js";
+export { useMcQuery, useMcLazyQuery, useMcMutation, } from "./hooks/apollo-hooks/index.js";
+export { buildApiUrl, createHttpClientOptions, executeHttpClientRequest, } from "./utils/http-client.js";
+export * as oidcStorage from "./utils/oidc-storage.js";
+export { setCachedApolloClient, getCachedApolloClient, } from "./utils/apollo-client-runtime-cache.js";