@wix/sdk 1.5.8 → 1.6.0

package/build/cjs/helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = exports.getDefaultContentHeader = void 0;
+// we follow a simplified version of the axios convention
+// https://github.com/axios/axios/blob/649d739288c8e2c55829ac60e2345a0f3439c730/lib/defaults/index.js#L65
+const getDefaultContentHeader = (options) => {
+    if (options?.method &&
+        ['post', 'put', 'patch'].includes(options.method.toLocaleLowerCase()) &&
+        options.body) {
+        return { 'Content-Type': 'application/json' };
+    }
+    return {};
+};
+exports.getDefaultContentHeader = getDefaultContentHeader;
+const isObject = (val) => val && typeof val === 'object' && !Array.isArray(val);
+exports.isObject = isObject;

package/build/cjs/host-modules.d.ts

@@ -0,0 +1,3 @@
+import { Host, HostModule } from '@wix/sdk-types';
+export declare const isHostModule: (val: any) => val is HostModule<unknown, Host>;
+export declare function buildHostModule(val: HostModule<unknown, Host>, host: Host): unknown;

package/build/cjs/host-modules.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHostModule = exports.isHostModule = void 0;
+const helpers_js_1 = require("./helpers.js");
+const isHostModule = (val) => (0, helpers_js_1.isObject)(val) && val.__type === 'host';
+exports.isHostModule = isHostModule;
+function buildHostModule(val, host) {
+    return val.create(host);
+}
+exports.buildHostModule = buildHostModule;

package/build/cjs/iframeUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function addListener(eventTarget: any, name: string, fn: Function): void;
+export declare function removeListener(eventTarget: any, name: string, fn: Function): void;
+export declare function loadFrame(src: string): HTMLIFrameElement;
+export declare function addPostMessageListener(state: string): Promise<unknown>;

package/build/cjs/iframeUtils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPostMessageListener = exports.loadFrame = exports.removeListener = exports.addListener = void 0;
+function addListener(eventTarget, name, fn) {
+    if (eventTarget.addEventListener) {
+        eventTarget.addEventListener(name, fn);
+    }
+    else {
+        eventTarget.attachEvent('on' + name, fn);
+    }
+}
+exports.addListener = addListener;
+function removeListener(eventTarget, name, fn) {
+    if (eventTarget.removeEventListener) {
+        eventTarget.removeEventListener(name, fn);
+    }
+    else {
+        eventTarget.detachEvent('on' + name, fn);
+    }
+}
+exports.removeListener = removeListener;
+function loadFrame(src) {
+    const iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    iframe.src = src;
+    return document.body.appendChild(iframe);
+}
+exports.loadFrame = loadFrame;
+function addPostMessageListener(state) {
+    let responseHandler;
+    let timeoutId;
+    const msgReceivedOrTimeout = new Promise((resolve, reject) => {
+        responseHandler = (e) => {
+            if (!e.data || e.data.state !== state) {
+                // A message not meant for us
+                return;
+            }
+            resolve(e.data);
+        };
+        addListener(window, 'message', responseHandler);
+        timeoutId = setTimeout(() => {
+            reject(new Error('OAuth flow timed out'));
+        }, 120000);
+    });
+    return msgReceivedOrTimeout.finally(() => {
+        clearTimeout(timeoutId);
+        removeListener(window, 'message', responseHandler);
+    });
+}
+exports.addPostMessageListener = addPostMessageListener;

package/build/cjs/index.d.ts

@@ -0,0 +1,9 @@
+export * from './wixClient.js';
+export * from './wixMedia.js';
+export * from './auth/oauth2/OAuthStrategy.js';
+export * from './auth/oauth2/types.js';
+export * from './auth/ApiKeyAuthStrategy.js';
+export * from './auth/WixAppOAuthStrategy.js';
+export * from '@wix/sdk-types';
+export { getDefaultDomain } from './rest-modules.js';
+export { API_URL } from './common.js';

package/build/cjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_URL = exports.getDefaultDomain = void 0;
+__exportStar(require("./wixClient.js"), exports);
+__exportStar(require("./wixMedia.js"), exports);
+__exportStar(require("./auth/oauth2/OAuthStrategy.js"), exports);
+__exportStar(require("./auth/oauth2/types.js"), exports);
+__exportStar(require("./auth/ApiKeyAuthStrategy.js"), exports);
+__exportStar(require("./auth/WixAppOAuthStrategy.js"), exports);
+__exportStar(require("@wix/sdk-types"), exports);
+var rest_modules_js_1 = require("./rest-modules.js");
+Object.defineProperty(exports, "getDefaultDomain", { enumerable: true, get: function () { return rest_modules_js_1.getDefaultDomain; } });
+var common_js_1 = require("./common.js");
+Object.defineProperty(exports, "API_URL", { enumerable: true, get: function () { return common_js_1.API_URL; } });

package/build/cjs/rest-modules.d.ts

@@ -0,0 +1,7 @@
+import { PublicMetadata } from './common.js';
+import { BuildRESTFunction, RESTFunctionDescriptor } from '@wix/sdk-types';
+export type RESTModuleOptions = {
+    HTTPHost?: string;
+};
+export declare const getDefaultDomain: (method: string, url: string) => "www.wixapis.com" | "readonly.wixapis.com";
+export declare function buildRESTDescriptor<T extends RESTFunctionDescriptor>(origFunc: T, publicMetadata: PublicMetadata, boundFetch: (url: string | URL, init?: RequestInit) => Promise<Response>, options?: RESTModuleOptions): BuildRESTFunction<T>;

package/build/cjs/rest-modules.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRESTDescriptor = exports.getDefaultDomain = void 0;
+const biHeaderGenerator_js_1 = require("./bi/biHeaderGenerator.js");
+const common_js_1 = require("./common.js");
+const getDefaultDomain = (method, url) => method === 'GET' &&
+    !common_js_1.FORCE_WRITE_API_URLS.some((write_url) => url === write_url)
+    ? common_js_1.READ_ONLY_API_URL
+    : common_js_1.API_URL;
+exports.getDefaultDomain = getDefaultDomain;
+function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, options) {
+    return origFunc({
+        request: async (factory) => {
+            const requestOptions = factory({ host: options?.HTTPHost || common_js_1.API_URL });
+            let request = requestOptions;
+            if (request.method === 'GET' &&
+                request.fallback?.length &&
+                request.params.toString().length > 4000) {
+                request = requestOptions.fallback[0];
+            }
+            const domain = options?.HTTPHost ?? (0, exports.getDefaultDomain)(request.method, request.url);
+            let url = `https://${domain}${request.url}`;
+            if (request.params && request.params.toString()) {
+                url += `?${request.params.toString()}`;
+            }
+            try {
+                const biHeader = (0, biHeaderGenerator_js_1.biHeaderGenerator)(requestOptions, publicMetadata);
+                const res = await boundFetch(url, {
+                    method: request.method,
+                    ...(request.data && {
+                        body: JSON.stringify(request.data),
+                    }),
+                    headers: {
+                        ...biHeader,
+                    },
+                });
+                if (res.status !== 200) {
+                    let dataError = null;
+                    try {
+                        dataError = await res.json();
+                    }
+                    catch (e) {
+                        //
+                    }
+                    throw errorBuilder(res.status, dataError?.message, dataError?.details, {
+                        requestId: res.headers.get('X-Wix-Request-Id'),
+                        details: dataError,
+                    });
+                }
+                const data = await res.json();
+                return {
+                    data,
+                    headers: res.headers,
+                    status: res.status,
+                    statusText: res.statusText,
+                };
+            }
+            catch (e) {
+                if (e.message?.includes('fetch is not defined')) {
+                    console.error('Node.js v18+ is required');
+                }
+                throw e;
+            }
+        },
+    });
+}
+exports.buildRESTDescriptor = buildRESTDescriptor;
+const errorBuilder = (code, description, details, data) => {
+    return {
+        response: {
+            data: {
+                details: {
+                    ...(!details?.validationError && {
+                        applicationError: {
+                            description,
+                            code,
+                            data,
+                        },
+                    }),
+                    ...details,
+                },
+                message: description,
+            },
+            status: code,
+        },
+    };
+};

package/build/cjs/tokenHelpers.d.ts

@@ -0,0 +1,4 @@
+import { AccessToken } from './auth/oauth2/types.js';
+export declare function getCurrentDate(): number;
+export declare function isTokenExpired(token: AccessToken): boolean;
+export declare function createAccessToken(accessToken: string, expiresIn: number): AccessToken;

package/build/cjs/tokenHelpers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccessToken = exports.isTokenExpired = exports.getCurrentDate = void 0;
+function getCurrentDate() {
+    return Math.floor(Date.now() / 1000);
+}
+exports.getCurrentDate = getCurrentDate;
+function isTokenExpired(token) {
+    const currentDate = getCurrentDate();
+    return token.expiresAt < currentDate;
+}
+exports.isTokenExpired = isTokenExpired;
+function createAccessToken(accessToken, expiresIn) {
+    const now = getCurrentDate();
+    return { value: accessToken, expiresAt: Number(expiresIn) + now };
+}
+exports.createAccessToken = createAccessToken;

package/build/cjs/wixClient.d.ts

@@ -0,0 +1,70 @@
+import { AuthenticationStrategy, BoundAuthenticationStrategy, BuildRESTFunction, Host, HostModule, HostModuleAPI, RESTFunctionDescriptor } from '@wix/sdk-types';
+import { ConditionalExcept, EmptyObject } from 'type-fest';
+import { AmbassadorFunctionDescriptor, BuildAmbassadorFunction } from './ambassador-modules.js';
+import { PublicMetadata } from './common.js';
+import type { GraphQLFormattedError } from 'graphql';
+type Headers = Record<string, string>;
+/**
+ * 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).
+ */
+export type BuildDescriptors<T extends Descriptors, H extends Host<any> | undefined> = BuildRESTDescriptors<T> & BuildAmbassadorDescriptors<T> & (H extends Host<any> ? BuildHostDescriptors<T> : {});
+type BuildRESTDescriptors<T extends Descriptors> = T extends RESTFunctionDescriptor ? BuildRESTFunction<T> : ConditionalExcept<{
+    [Key in keyof T]: T[Key] extends Descriptors ? BuildRESTDescriptors<T[Key]> : never;
+}, EmptyObject>;
+type BuildAmbassadorDescriptors<T extends Descriptors> = T extends AmbassadorFunctionDescriptor ? BuildAmbassadorFunction<T> : ConditionalExcept<{
+    [Key in keyof T]: T[Key] extends Descriptors ? BuildAmbassadorDescriptors<T[Key]> : never;
+}, EmptyObject>;
+type BuildHostDescriptors<T extends Descriptors> = T extends HostModule<any, any> ? HostModuleAPI<T> : ConditionalExcept<{
+    [Key in keyof T]: T[Key] extends Descriptors ? BuildHostDescriptors<T[Key]> : never;
+}, EmptyObject>;
+/**
+ * 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.
+ */
+export type Descriptors = RESTFunctionDescriptor | AmbassadorFunctionDescriptor | HostModule<any, any> | {
+    [key: string]: Descriptors | PublicMetadata | any;
+};
+/**
+ * This type is used in `createClient` to ensure that the given host matches the host of the given descriptors.
+ * If the host does not match, the descriptor is replaced with a host module that will throw an error when used.
+ */
+export type AssertHostMatches<T extends Descriptors, H extends Host<any>> = T extends HostModule<any, infer U> ? H extends undefined ? never : H extends U ? T : HostModule<any, H> : T extends RESTFunctionDescriptor<any> ? T : {
+    [Key in keyof T]: T[Key] extends Descriptors ? AssertHostMatches<T[Key], H> : T[Key];
+};
+type TypedQueryInput<Result = {
+    [key: string]: any;
+}, Variables = {
+    [key: string]: any;
+}> = {
+    /**
+     * Type to support `@graphql-typed-document-node/core`
+     * @internal
+     */
+    __apiType?: (variables: Variables) => Result;
+    /**
+     * Type to support `TypedQueryDocumentNode` from `graphql`
+     * @internal
+     */
+    __ensureTypesOfVariablesAndResultMatching?: (variables: Variables) => Result;
+};
+export type WixClient<H extends Host<any> | undefined = undefined, Z extends AuthenticationStrategy<H> = AuthenticationStrategy<H>, T extends Descriptors = Descriptors> = {
+    setHeaders(headers: Headers): void;
+    auth: Omit<Z, 'getAuthHeaders'> & BoundAuthenticationStrategy;
+    fetch(relativeUrl: string, options: RequestInit): Promise<Response>;
+    use<R extends Descriptors = EmptyObject>(modules: H extends Host<any> ? AssertHostMatches<R, H> : R): BuildDescriptors<R, H>;
+    graphql<Result, Variables>(query: string | ((string | String) & TypedQueryInput<Result, Variables>), variables?: Variables): Promise<{
+        data: Result;
+        errors?: GraphQLFormattedError[];
+    }>;
+} & BuildDescriptors<T, H>;
+export declare function createClient<H extends Host<any> | undefined = undefined, Z extends AuthenticationStrategy<H> = AuthenticationStrategy<H>, T extends Descriptors = EmptyObject>(config: {
+    modules?: H extends Host<any> ? AssertHostMatches<T, H> : T;
+    auth?: Z;
+    headers?: Headers;
+    host?: H;
+}): WixClient<H, Z, T>;
+export {};

package/build/cjs/wixClient.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = void 0;
+const ambassador_modules_js_1 = require("./ambassador-modules.js");
+const common_js_1 = require("./common.js");
+const helpers_js_1 = require("./helpers.js");
+const host_modules_js_1 = require("./host-modules.js");
+const rest_modules_js_1 = require("./rest-modules.js");
+const fetch_error_js_1 = require("./fetch-error.js");
+function createClient(config) {
+    const _headers = config.headers || { Authorization: '' };
+    const authStrategy = config.auth || {
+        getAuthHeaders: () => Promise.resolve({ headers: {} }),
+    };
+    const boundGetAuthHeaders = authStrategy.getAuthHeaders.bind(undefined, config.host);
+    authStrategy.getAuthHeaders = boundGetAuthHeaders;
+    const boundFetch = async (url, options) => {
+        const authHeaders = await boundGetAuthHeaders();
+        const defaultContentTypeHeader = (0, helpers_js_1.getDefaultContentHeader)(options);
+        return fetch(url, {
+            ...options,
+            headers: {
+                ...defaultContentTypeHeader,
+                ..._headers,
+                ...authHeaders?.headers,
+                ...options?.headers,
+            },
+        });
+    };
+    // This is typed as `any` because when trying to properly type it as defined
+    // on the WixClient, typescript starts failing with `Type instantiation is
+    // excessively deep and possibly infinite.`
+    const use = (modules, metadata) => {
+        if ((0, host_modules_js_1.isHostModule)(modules) && config.host) {
+            return (0, host_modules_js_1.buildHostModule)(modules, config.host);
+        }
+        else if (typeof modules === 'function') {
+            const { module, options } = (0, ambassador_modules_js_1.isAmbassadorModule)(modules)
+                ? {
+                    module: (0, ambassador_modules_js_1.toHTTPModule)(modules),
+                    options: (0, ambassador_modules_js_1.ambassadorModuleOptions)(),
+                }
+                : { module: modules, options: undefined };
+            return (0, rest_modules_js_1.buildRESTDescriptor)(module, metadata ?? {}, boundFetch, options);
+        }
+        else if ((0, helpers_js_1.isObject)(modules)) {
+            return Object.fromEntries(Object.entries(modules).map(([key, value]) => {
+                return [key, use(value, modules[common_js_1.PUBLIC_METADATA_KEY])];
+            }));
+        }
+        else {
+            return modules;
+        }
+    };
+    const setHeaders = (headers) => {
+        for (const k in headers) {
+            _headers[k] = headers[k];
+        }
+    };
+    const wrappedModules = config.modules ? use(config.modules) : {};
+    return {
+        ...wrappedModules,
+        auth: authStrategy,
+        setHeaders,
+        use,
+        fetch: (relativeUrl, options) => {
+            const finalUrl = new URL(relativeUrl, `https://${common_js_1.API_URL}`);
+            finalUrl.host = common_js_1.API_URL;
+            finalUrl.protocol = 'https';
+            return boundFetch(finalUrl.toString(), options);
+        },
+        async graphql(query, variables, opts = {
+            apiVersion: 'alpha',
+        }) {
+            const res = await boundFetch(`https://${common_js_1.API_URL}/graphql/${opts.apiVersion}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ query, variables }),
+            });
+            if (res.status !== 200) {
+                throw new fetch_error_js_1.FetchErrorResponse(`GraphQL request failed with status ${res.status}`, res);
+            }
+            const { data, errors } = await res.json();
+            return { data: data ?? {}, errors };
+        },
+    };
+}
+exports.createClient = createClient;

package/build/cjs/wixMedia.d.ts

@@ -0,0 +1,46 @@
+import { ImageTransformOptions } from '@wix/image-kit';
+declare function getScaledToFillImageUrl(wixMediaIdentifier: string, targetWidth: number, targetHeight: number, options: ImageTransformOptions): string;
+declare function getScaledToFitImageUrl(wixMediaIdentifier: string, targetWidth: number, targetHeight: number, options: ImageTransformOptions): string;
+declare function getCroppedImageUrl(wixMediaIdentifier: string, cropX: number, cropY: number, cropWidth: number, cropHeight: number, targetWidth: number, targetHeight: number, options?: ImageTransformOptions): string;
+declare function getImageUrl(val: string): {
+    id: string;
+    url: string;
+    height: number;
+    width: number;
+    altText?: string;
+    filename?: string;
+};
+declare function getVideoUrl(val: string, resolution?: VideoResolution): {
+    id: string;
+    url: string;
+    thumbnail: string;
+    filename?: string;
+};
+declare function getAudioUrl(val: string): {
+    id: string;
+    url: string;
+    duration: number;
+    filename?: string;
+};
+declare function getDocumentUrl(val: string): {
+    id: string;
+    url: string;
+    filename?: string;
+};
+export declare function decodeText(s: string): string;
+export declare enum VideoResolution {
+    MOBILE = "360p",
+    LOW = "480p",
+    MID = "720p",
+    HIGH = "1080p"
+}
+export declare const media: {
+    getCroppedImageUrl: typeof getCroppedImageUrl;
+    getScaledToFillImageUrl: typeof getScaledToFillImageUrl;
+    getScaledToFitImageUrl: typeof getScaledToFitImageUrl;
+    getImageUrl: typeof getImageUrl;
+    getVideoUrl: typeof getVideoUrl;
+    getAudioUrl: typeof getAudioUrl;
+    getDocumentUrl: typeof getDocumentUrl;
+};
+export {};

package/build/cjs/wixMedia.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.media = exports.VideoResolution = exports.decodeText = void 0;
+const image_kit_1 = require("@wix/image-kit");
+const WIX_PROTOCOL = 'wix:';
+const WIX_IMAGE = 'image';
+const WIX_VIDEO = 'video';
+const WIX_AUDIO = 'audio';
+const WIX_DOCUMENT = 'document';
+const WIX_IMAGE_URL = 'https://static.wixstatic.com/media/';
+const WIX_VIDEO_URL = 'https://video.wixstatic.com/video/';
+const WIX_AUDIO_URL = 'https://static.wixstatic.com/mp3/';
+const WIX_DOCUMENT_URL = 'https://d945e594-8657-47e2-9cd9-e9033c3d8da0.usrfiles.com/ugd/';
+function getScaledToFillImageUrl(wixMediaIdentifier, targetWidth, targetHeight, options) {
+    const img = getImageUrl(wixMediaIdentifier);
+    return image_kit_1.sdk.getScaleToFillImageURL(img.id, img.height, img.width, targetWidth, targetHeight, options);
+}
+function getScaledToFitImageUrl(wixMediaIdentifier, targetWidth, targetHeight, options) {
+    const img = getImageUrl(wixMediaIdentifier);
+    return image_kit_1.sdk.getScaleToFitImageURL(img.id, img.height, img.width, targetWidth, targetHeight, options);
+}
+function getCroppedImageUrl(wixMediaIdentifier, cropX, cropY, cropWidth, cropHeight, targetWidth, targetHeight, options) {
+    const img = getImageUrl(wixMediaIdentifier);
+    return image_kit_1.sdk.getCropImageURL(img.id, img.height, img.width, cropX, cropY, cropWidth, cropHeight, targetWidth, targetHeight, options);
+}
+function getImageUrl(val) {
+    let id, filenameOrAltText;
+    let height, width;
+    if (val.startsWith(WIX_IMAGE_URL)) {
+        id = val.split(WIX_IMAGE_URL).pop().split('/')[0];
+        width = val.split('/w_').pop().split(',')[0];
+        height = val.split(',h_').pop().split(',')[0];
+    }
+    else {
+        const alignedImage = alignIfLegacy(val, WIX_IMAGE);
+        const { hash, pathname } = new URL(alignedImage);
+        const params = new URLSearchParams(hash.replace('#', ''));
+        height = params.get('originHeight');
+        width = params.get('originWidth');
+        [id, filenameOrAltText] = pathname
+            .replace(`${WIX_IMAGE}://v1/`, '')
+            .split('/');
+    }
+    // @ts-expect-error
+    const decodedFilenameOrAltText = decodeText(filenameOrAltText);
+    const res = {
+        id,
+        url: `${WIX_IMAGE_URL}${id}`,
+        height: Number(height),
+        width: Number(width),
+    };
+    if (!decodedFilenameOrAltText) {
+        return res;
+    }
+    return {
+        ...res,
+        altText: decodedFilenameOrAltText,
+        filename: decodedFilenameOrAltText,
+    };
+}
+function getVideoUrl(val, resolution) {
+    let id, thumbnailId, thumbnailWidth, thumbnailHeight, decodedFilename = '';
+    if (val.startsWith(WIX_VIDEO_URL)) {
+        id = val.split(WIX_VIDEO_URL).pop().split('/')[0];
+        thumbnailId = `${id}.jpg`;
+        thumbnailWidth = '50';
+        thumbnailHeight = '50';
+    }
+    else {
+        const alignedVideo = alignIfLegacy(val, WIX_VIDEO);
+        const { pathname, hash } = new URL(alignedVideo);
+        const hashParams = new URLSearchParams(hash.replace('#', ''));
+        const [_id, fileName] = pathname
+            .replace(`${WIX_VIDEO}://v1/`, '')
+            .split('/');
+        id = _id;
+        thumbnailId = hashParams.get('posterUri') || `${id}.jpg`;
+        thumbnailWidth = hashParams.get('posterWidth') || '50';
+        thumbnailHeight = hashParams.get('posterHeight') || '50';
+        decodedFilename = decodeText(fileName);
+    }
+    const res = {
+        id,
+        url: `${WIX_VIDEO_URL}${id}/${resolution ? `${resolution}/mp4/file.mp4` : 'file'}`,
+        thumbnail: `${WIX_PROTOCOL}${WIX_IMAGE}://v1/${thumbnailId}#originWidth=${thumbnailWidth}&originHeight=${thumbnailHeight}`,
+    };
+    if (!decodedFilename) {
+        return res;
+    }
+    return {
+        ...res,
+        filename: decodedFilename,
+    };
+}
+function getAudioUrl(val) {
+    const alignedAudio = alignIfLegacy(val, WIX_AUDIO);
+    const { pathname, hash } = new URL(alignedAudio);
+    const [id, filename] = pathname.replace(`${WIX_AUDIO}://v1/`, '').split('/');
+    const decodedFilename = decodeText(filename);
+    const hashParams = new URLSearchParams(hash.replace('#', ''));
+    const res = {
+        id,
+        duration: Number(hashParams.get('duration') || ''),
+        url: `${WIX_AUDIO_URL}${id}`,
+    };
+    if (!decodedFilename) {
+        return res;
+    }
+    return {
+        ...res,
+        filename: decodedFilename,
+    };
+}
+function getDocumentUrl(val) {
+    const valWithoutUGD = val.replace('v1/ugd', 'v1');
+    const alignedDocument = alignIfLegacy(valWithoutUGD, WIX_DOCUMENT);
+    const { pathname } = new URL(alignedDocument);
+    const [id, filename] = pathname
+        .replace(`${WIX_DOCUMENT}://v1/`, '')
+        .split('/');
+    const decodedFilename = decodeText(filename);
+    const res = {
+        id,
+        url: `${WIX_DOCUMENT_URL}${id}`,
+    };
+    if (!decodedFilename) {
+        return res;
+    }
+    return {
+        ...res,
+        filename: decodedFilename,
+    };
+}
+function decodeText(s) {
+    if (!s) {
+        return s;
+    }
+    return decodeURIComponent(s);
+}
+exports.decodeText = decodeText;
+function alignIfLegacy(url, type) {
+    const { protocol } = new URL(url);
+    return protocol === `${type}:` ? `${WIX_PROTOCOL}${url}` : url;
+}
+var VideoResolution;
+(function (VideoResolution) {
+    VideoResolution["MOBILE"] = "360p";
+    VideoResolution["LOW"] = "480p";
+    VideoResolution["MID"] = "720p";
+    VideoResolution["HIGH"] = "1080p";
+})(VideoResolution || (exports.VideoResolution = VideoResolution = {}));
+exports.media = {
+    getCroppedImageUrl,
+    getScaledToFillImageUrl,
+    getScaledToFitImageUrl,
+    getImageUrl,
+    getVideoUrl,
+    getAudioUrl,
+    getDocumentUrl,
+};

package/build/esm/ambassador-modules.d.ts

@@ -0,0 +1,31 @@
+import type { HttpClient as SDKHttpClient } from '@wix/sdk-types';
+import { RESTModuleOptions } from './rest-modules.js';
+export type RequestContext = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+/**
+ * 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
+ */
+export type Method = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type ResponseTransformer = (data: any, headers?: any) => any;
+export type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+export type AmbassadorFactory<Request, Response> = (payload: Request) => ((context: RequestContext) => AmbassadorRequestOptions<Response>) & {
+    __isAmbassador: boolean;
+};
+export type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+export type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+export declare const toHTTPModule: <Request_1, Response_1>(factory: AmbassadorFactory<Request_1, Response_1>) => (httpClient: SDKHttpClient) => (payload: Request_1) => Promise<Response_1>;
+export declare const ambassadorModuleOptions: () => RESTModuleOptions;
+export declare const isAmbassadorModule: (module: any) => boolean;
+export {};