@wix/sdk-types 1.13.10 → 1.13.12

package/internal/build/browser/index.d.mts

@@ -0,0 +1,416 @@
+import { MonitoringClient } from '@wix/monitoring-types';
+import { ConditionalExcept, EmptyObject, Simplify, Paths, SetRequiredDeep } from 'type-fest';
+
+interface BiLogger {
+    log(params: LogParams, context?: LogOptions): Promise<any>;
+    log(eventName: string, params: LogParams, context?: LogOptions): Promise<any>;
+    report(reportProps: ReportProps): Promise<any>;
+    flush(): Promise<any>;
+    updateDefaults(params: LogParams): this;
+}
+interface LogParams {
+    [key: string]: any;
+}
+interface LogOptions {
+    endpoint?: string;
+    useBatch?: number | boolean;
+    category?: EventCategories;
+}
+interface ReportProps {
+    evid: number;
+    src: number;
+    endpoint: string;
+    params: LogParams;
+}
+declare enum EventCategories {
+    Essential = "essential",
+    Functional = "functional",
+    Analytics = "analytics"
+}
+
+declare class ReadOnlyExperiments {
+    protected experiments: ExperimentsBag;
+    constructor(options: ReadOnlyExperimentsOptions);
+    get(key: string): any;
+    enabled(key: string): boolean;
+    pending(): boolean;
+    ready(): Promise<any>;
+    all(): ExperimentsBag;
+}
+declare class Experiments extends ReadOnlyExperiments {
+    private readonly loaders;
+    private readonly baseUrl;
+    private requestContext;
+    readonly useNewApi: boolean;
+    private onError;
+    constructor(obj?: ExperimentsProps);
+    add(obj: ExperimentsBag): void;
+    private _addLoader;
+    private _getUrlWithFallback;
+    load(scope: string): Promise<void>;
+    conduct(spec: string, fallbackValue?: string): Promise<string>;
+    pending(): boolean;
+    ready(): Promise<any>;
+    _addConductResult(spec: string, conductResponse: string): Promise<string>;
+}
+interface ExperimentsBag {
+    [key: string]: string | boolean;
+}
+interface ReadOnlyExperimentsOptions {
+    experiments?: ExperimentsBag;
+}
+interface ExperimentsProps extends ReadOnlyExperimentsOptions {
+    useNewApi?: boolean;
+    baseUrl?: string;
+    scope?: string;
+    scopes?: string[];
+    requestContext?: RequestContext$1;
+    onError?: (error: Error) => void;
+}
+type RequestContext$1 = RequestContextMetasite & OneOf<RequestContextOwner, RequestContextVisitors>;
+interface RequestContextMetasite {
+    overrideCriteria?: {
+        entityId: string;
+    };
+}
+interface RequestContextOwner {
+    forSiteOwner?: {
+        loggedInUserId: string;
+        siteOwnerId: string;
+    };
+}
+interface RequestContextVisitors {
+    forSiteVisitors?: {
+        visitorId: string;
+        siteOwnerId: string;
+    };
+}
+type OneOf<T1, T2> = ({
+    [P in keyof T1]?: never;
+} & T2) | ({
+    [P in keyof T2]?: never;
+} & T1);
+
+type Conductor = {
+    isFeatureOn: (featureName: string) => boolean;
+    getABTestVariant: (abTestName: string) => 'a' | 'b' | 'c' | 'd' | 'e';
+};
+
+type HostModule<T, H extends Host> = {
+    __type: 'host';
+    create(host: H): T;
+};
+type HostModuleAPI<T extends HostModule<any, any>> = T extends HostModule<infer U, any> ? U : never;
+type Host<Environment = unknown> = {
+    channel?: {
+        observeState(callback: (props: unknown, environment: Environment) => unknown): {
+            disconnect: () => void;
+        } | Promise<{
+            disconnect: () => void;
+        }>;
+    };
+    environment?: Environment;
+    /**
+     * Optional name of the environment, use for logging
+     */
+    name?: string;
+    /**
+     * Optional bast url to use for API requests, for example `www.wixapis.com`
+     */
+    apiBaseUrl?: string;
+    /**
+     * Optional function to get a monitoring client
+     */
+    getMonitoringClient?: () => MonitoringClient;
+    /**
+     * Optional function to get a bi logger
+     * @internal
+     */
+    getBiLogger?: () => BiLogger;
+    /**
+     * Optional function to get petri experiments
+     * @internal
+     */
+    getPetriExperimentsClient?: () => Experiments;
+    /**
+     * Optional function to get conductor experiments
+     * @internal
+     */
+    getConductorClient?: () => Conductor;
+    /**
+     * Possible data to be provided by every host, for cross cutting concerns
+     * like internationalization, billing, etc.
+     */
+    essentials?: {
+        /**
+         * The language of the currently viewed session
+         */
+        language?: string;
+        /**
+         * The locale of the currently viewed session
+         */
+        locale?: string;
+        /**
+         * Any headers that should be passed through to the API requests
+         */
+        passThroughHeaders?: Record<string, string>;
+    };
+};
+
+type HTTPMethod = 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+    getActiveToken?: () => string | undefined;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: HTTPMethod;
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+type RestModuleMeta<TMethod extends HTTPMethod = HTTPMethod, TPathParams = unknown, RequestType = unknown, TOriginalRequestType = unknown, ResponseType = unknown, OriginalResponseType = unknown> = {
+    getUrl(context: {
+        host: string;
+    }): string;
+    httpMethod: TMethod;
+    pathParams: TPathParams;
+    path: string;
+    __requestType: RequestType;
+    __originalRequestType: TOriginalRequestType;
+    __responseType: ResponseType;
+    __originalResponseType: OriginalResponseType;
+};
+
+type AuthenticationStrategy<Host = unknown> = {
+    getAuthHeaders: (host: Host) => Promise<{
+        headers: Record<string, string>;
+    }> | {
+        headers: Record<string, string>;
+    };
+    decodeJWT?: (token: string, verifyCallerClaims?: boolean) => Promise<{
+        decoded: {
+            data: unknown;
+        };
+        valid: boolean;
+    }>;
+    /**
+     * This function is used to get the token that is currently active in the context of the strategy.
+     * This is useful when direct access to the access token is needed
+     * (such as getTokenInfo that requires the token in the body of the request).
+     * @returns the token that is currently active in the context of the strategy
+     */
+    getActiveToken?: () => string | undefined;
+};
+type BoundAuthenticationStrategy = {
+    getAuthHeaders: () => Promise<{
+        headers: Record<string, string>;
+    }> | {
+        headers: Record<string, string>;
+    };
+};
+
+type EventIdentity = {
+    identityType: 'ANONYMOUS_VISITOR' | 'MEMBER' | 'WIX_USER' | 'APP';
+    anonymousVisitorId: string;
+    memberId: string;
+    wixUserId: string;
+    appId: string;
+};
+type BaseEventMetadata = {
+    instanceId: string;
+    identity?: EventIdentity;
+};
+type EventDefinition<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: (envelope: unknown) => Payload;
+    __payload: Payload;
+};
+declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, transformations?: (envelope: any) => unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
+type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+
+type ServicePluginMethodInput = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract = Record<string, (payload: ServicePluginMethodInput) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition<Contract extends ServicePluginContract> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition<Contract extends ServicePluginContract>(componentType: string, methods: ServicePluginMethodMetadata[]): ServicePluginDefinition<Contract>;
+type BuildServicePluginDefinition<T extends ServicePluginDefinition<any>> = (implementation: T['__contract']) => void;
+declare const SERVICE_PLUGIN_ERROR_TYPE = "wix_spi_error";
+
+type RequestContext = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+type ResponseTransformer = (data: any, headers?: any) => any;
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+type Method = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+type AmbassadorFactory<Request, Response> = (payload: Request) => ((context: RequestContext) => AmbassadorRequestOptions<Response>) & {
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+type Descriptors = RESTFunctionDescriptor | AmbassadorFunctionDescriptor | HostModule<any, any> | EventDefinition<any> | ServicePluginDefinition<any> | {
+    [key: string]: Descriptors | PublicMetadata | any;
+};
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+type BuildDescriptors<T extends Descriptors, H extends Host<any> | undefined, Depth extends number = 5> = {
+    done: T;
+    recurse: T extends {
+        __type: typeof SERVICE_PLUGIN_ERROR_TYPE;
+    } ? never : T extends AmbassadorFunctionDescriptor ? BuildAmbassadorFunction<T> : T extends RESTFunctionDescriptor ? BuildRESTFunction<T> : T extends EventDefinition<any> ? BuildEventDefinition<T> : T extends ServicePluginDefinition<any> ? BuildServicePluginDefinition<T> : T extends HostModule<any, any> ? HostModuleAPI<T> : ConditionalExcept<{
+        [Key in keyof T]: T[Key] extends Descriptors ? BuildDescriptors<T[Key], H, [
+            -1,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ][Depth]> : never;
+    }, EmptyObject>;
+}[Depth extends -1 ? 'done' : 'recurse'];
+type PublicMetadata = {
+    PACKAGE_NAME?: string;
+};
+
+declare global {
+    interface ContextualClient {
+    }
+}
+/**
+ * A type used to create concerete types from SDK descriptors in
+ * case a contextual client is available.
+ */
+type MaybeContext<T extends Descriptors> = globalThis.ContextualClient extends {
+    host: Host;
+} ? BuildDescriptors<T, globalThis.ContextualClient['host']> : T;
+
+/**
+ * Expose fields based on the current exposure toggle.
+ * @param T - The type to expose fields from.
+ * @param FieldsScope - A map of fields to their exposure scope, missing fields are considered public.
+ * @example Exposure toggle not set:
+ * ```ts
+ * type MyType = {
+ *  publicField: string;
+ *  alphaField: string;
+ * };
+ *
+ * type ExposedType = ExposeFieldsBasedOnToggle<MyType, { alphaField: 'alpha' }>;
+ * // ExposedType = { publicField: string; }
+ * ```
+ * @example Exposure toggle set to alpha:
+ * ```ts
+ * declare global {
+ *  interface SDKExposureToggle {
+ *   alpha: true;
+ *  }
+ * }
+ *
+ * type MyType = {
+ *  publicField: string;
+ *  alphaField: string;
+ * };
+ *
+ * type ExposedType = ExposeFieldsBasedOnToggle<MyType, { alphaField: 'alpha' }>;
+ * // ExposedType = { publicField: string; alphaField: string; }
+ */
+type ExposeFieldsBasedOnToggle<T extends Record<string, any>, FieldsScope extends Partial<Record<keyof T, Exposure>>> = Simplify<{
+    [K in keyof T as IsExposed<K, FieldsScope[K] extends Exposure ? FieldsScope[K] : 'public'>]: T[K];
+}>;
+declare global {
+    /**
+     * A global interface to set the exposure toggle for the SDK.
+     * @example
+     * ```ts
+     * declare global {
+     *  interface SDKExposureToggle {
+     *    alpha: true;
+     *  }
+     * }
+     */
+    interface SDKExposureToggle {
+    }
+}
+type Exposure = 'alpha' | 'public';
+type IsExposed<T, Scope extends Exposure> = Scope extends 'public' ? T : globalThis.SDKExposureToggle extends {
+    alpha: true;
+} ? T : never;
+
+declare global {
+    /**
+     * A global interface to set the type mode for the SDK.
+     * @example
+     * ```ts
+     * declare global {
+     *  interface SDKTypeMode {
+     *    strict: true;
+     *  }
+     * }
+     */
+    interface SDKTypeMode {
+    }
+}
+type NonNullablePaths<T, K extends Paths<T>> = globalThis.SDKTypeMode extends {
+    strict: true;
+} ? SetRequiredDeep<T, K> : T;
+
+export { type APIMetadata, type AmbassadorFactory, type AmbassadorFunctionDescriptor, type AmbassadorRequestOptions, type AuthenticationStrategy, type BaseEventMetadata, type BoundAuthenticationStrategy, type BuildAmbassadorFunction, type BuildDescriptors, type BuildEventDefinition, type BuildRESTFunction, type BuildServicePluginDefinition, type Descriptors, EventDefinition, type EventHandler, type EventIdentity, type ExposeFieldsBasedOnToggle, type HTTPMethod, type Host, type HostModule, type HostModuleAPI, type HttpClient, type HttpResponse, type MaybeContext, type Method, type NonNullablePaths, type PublicMetadata, type RESTFunctionDescriptor, type RequestContext, type RequestOptions, type RequestOptionsFactory, type RestModuleMeta, SERVICE_PLUGIN_ERROR_TYPE, type ServicePluginContract, ServicePluginDefinition, type ServicePluginMethodInput, type ServicePluginMethodMetadata };

package/internal/build/browser/index.mjs

@@ -0,0 +1,24 @@
+// src/event-handlers-modules.ts
+function EventDefinition(type, isDomainEvent = false, transformations = (x) => x) {
+  return () => ({
+    __type: "event-definition",
+    type,
+    isDomainEvent,
+    transformations
+  });
+}
+
+// src/service-plugins.ts
+function ServicePluginDefinition(componentType, methods) {
+  return {
+    __type: "service-plugin-definition",
+    componentType,
+    methods
+  };
+}
+var SERVICE_PLUGIN_ERROR_TYPE = "wix_spi_error";
+export {
+  EventDefinition,
+  SERVICE_PLUGIN_ERROR_TYPE,
+  ServicePluginDefinition
+};