@calmlens/sdk 0.16.2 → 0.17.1

package/cjs/vue.js

@@ -0,0 +1,419 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ui = require("./ui-KceuoVCM.js");
+const require_UploadController = require("./UploadController-BBkN4Ni6.js");
+const require_BrowserUpload = require("./BrowserUpload-DZ0Vbmxi.js");
+let vue = require("vue");
+// src/vue.ts
+const icon = (name) => (0, vue.h)("svg", require_ui.ICON_ATTRIBUTES, [(0, vue.h)("path", { d: require_ui.ICONS[name] })]);
+/** Keeps a ref to a controller's snapshot, following the controller if it changes. */
+const subscribeSnapshot = (controller) => {
+	const snapshot = (0, vue.shallowRef)((0, vue.toValue)(controller).getSnapshot());
+	(0, vue.watch)(() => (0, vue.toValue)(controller), (current, _previous, onCleanup) => {
+		onCleanup(current.subscribe((next) => {
+			snapshot.value = next;
+		}));
+	}, { immediate: true });
+	return snapshot;
+};
+/**
+* Uploads files through an upload preset and keeps `snapshot` up to date as each one uploads and
+* is checked. Use it to build your own upload UI; `CalmLensUploader` is built on it. Uploads
+* still running when the component unmounts are cancelled.
+*/
+const useCalmLensUpload = (options) => {
+	const controller = require_UploadController.createUploadController((0, vue.toValue)(options));
+	(0, vue.watchEffect)(() => controller.setOptions((0, vue.toValue)(options)));
+	const snapshot = subscribeSnapshot(controller);
+	(0, vue.onScopeDispose)(() => controller.clear());
+	return {
+		snapshot,
+		controller,
+		addFiles: (files) => controller.addFiles(files),
+		retry: (key) => controller.retry(key),
+		cancel: (key) => controller.cancel(key),
+		remove: (key) => controller.remove(key),
+		clear: () => controller.clear(),
+		start: () => controller.start()
+	};
+};
+const optional = (type) => ({
+	type,
+	default: void 0
+});
+const messagesProp = optional(Object);
+/**
+* A drop zone and file list that uploads through an upload preset, shows each file's progress
+* and moderation decision, and emits `uploaded` for finished uploads.
+*/
+const CalmLensUploader = (0, vue.defineComponent)({
+	name: "CalmLensUploader",
+	props: {
+		uploadPresetId: optional(String),
+		upload: optional(Function),
+		checkStatus: optional(Function),
+		createClient: optional(Function),
+		token: optional([String, Function]),
+		tokenUrl: optional(String),
+		accept: optional(String),
+		maxFileSize: optional(Number),
+		autoUpload: {
+			type: Boolean,
+			default: true
+		},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		maxFiles: optional(Number),
+		concurrency: optional(Number),
+		decisionTimeoutMs: optional(Number),
+		baseUrl: optional(String),
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		capture: optional(String),
+		messages: messagesProp,
+		controller: optional(Object)
+	},
+	emits: {
+		uploaded: (_upload) => true,
+		rejected: (_item) => true,
+		failed: (_item) => true,
+		removed: (_item) => true
+	},
+	setup(props, { emit }) {
+		const own = useCalmLensUpload(() => ({
+			uploadPresetId: props.uploadPresetId,
+			upload: props.upload,
+			checkStatus: props.checkStatus,
+			createClient: props.createClient,
+			token: props.token,
+			tokenUrl: props.tokenUrl,
+			accept: props.accept,
+			maxFileSize: props.maxFileSize,
+			autoUpload: props.autoUpload,
+			multiple: props.multiple,
+			maxFiles: props.maxFiles,
+			concurrency: props.concurrency,
+			decisionTimeoutMs: props.decisionTimeoutMs,
+			baseUrl: props.baseUrl,
+			onUploaded: (value) => emit("uploaded", value),
+			onRejected: (item) => emit("rejected", item),
+			onFailed: (item) => emit("failed", item),
+			onRemoved: (item) => emit("removed", item)
+		}));
+		const controller = (0, vue.computed)(() => props.controller ?? own.controller);
+		const snapshot = subscribeSnapshot(controller);
+		const messages = (0, vue.computed)(() => require_ui.resolveMessages(props.messages));
+		const dragging = (0, vue.ref)(false);
+		const input = (0, vue.ref)();
+		const openPicker = () => {
+			if (!props.disabled) input.value?.click();
+		};
+		const onDragOver = (event) => {
+			event.preventDefault();
+			if (!props.disabled) dragging.value = true;
+		};
+		return () => {
+			const text = messages.value;
+			const queue = controller.value;
+			const { accept, multiple } = queue.options;
+			const items = snapshot.value.items;
+			const view = require_ui.describeUploader(snapshot.value, queue.options, text);
+			return (0, vue.h)("div", { class: "calmlens-uploader" }, [
+				view.showDropzone && (0, vue.h)("div", {
+					class: "calmlens-dropzone",
+					"data-dragging": dragging.value || void 0,
+					"data-disabled": props.disabled || void 0,
+					onClick: openPicker,
+					onDragover: onDragOver,
+					onDragenter: onDragOver,
+					onDragleave: (event) => {
+						if (!event.currentTarget.contains(event.relatedTarget)) dragging.value = false;
+					},
+					onDrop: (event) => {
+						event.preventDefault();
+						dragging.value = false;
+						if (!props.disabled && event.dataTransfer) queue.addFiles(event.dataTransfer.files);
+					},
+					onPaste: (event) => {
+						const files = event.clipboardData?.files;
+						if (!props.disabled && files?.length) queue.addFiles(files);
+					}
+				}, [
+					(0, vue.h)("span", { class: "calmlens-dropzone__icon" }, [icon("upload")]),
+					(0, vue.h)("div", { class: "calmlens-dropzone__text" }, [(0, vue.h)("p", { class: "calmlens-dropzone__title" }, dragging.value ? text.dropzoneTitleDragging : text.dropzoneTitle), view.hint && (0, vue.h)("p", { class: "calmlens-dropzone__hint" }, view.hint)]),
+					(0, vue.h)("button", {
+						type: "button",
+						class: "calmlens-button",
+						"data-variant": "outline",
+						disabled: props.disabled,
+						onClick: (event) => {
+							event.stopPropagation();
+							openPicker();
+						}
+					}, view.chooseLabel)
+				]),
+				(0, vue.h)("input", {
+					ref: input,
+					type: "file",
+					hidden: true,
+					accept,
+					multiple,
+					capture: props.capture,
+					disabled: props.disabled,
+					onChange: (event) => {
+						const target = event.target;
+						if (target.files) queue.addFiles(target.files);
+						target.value = "";
+					}
+				}),
+				items.length > 0 && (0, vue.h)("ul", { class: "calmlens-uploads" }, items.map((item) => {
+					const itemView = require_ui.describeUploadItem(item, text);
+					return (0, vue.h)("li", {
+						key: item.key,
+						class: "calmlens-upload",
+						"data-stage": item.stage,
+						"data-outcome": itemView.outcome
+					}, [
+						item.previewUrl ? (0, vue.h)("img", {
+							class: "calmlens-upload__thumb",
+							src: item.previewUrl,
+							alt: ""
+						}) : (0, vue.h)("span", {
+							class: "calmlens-upload__thumb",
+							"data-kind": "file",
+							"aria-hidden": "true",
+							innerHTML: itemView.fileIcon
+						}),
+						(0, vue.h)("div", { class: "calmlens-upload__body" }, [
+							(0, vue.h)("span", { class: "calmlens-upload__name" }, item.file.name),
+							(0, vue.h)("span", { class: "calmlens-upload__size" }, itemView.size),
+							itemView.busy && (0, vue.h)("div", {
+								class: "calmlens-progress",
+								role: "progressbar",
+								"aria-label": itemView.message,
+								"aria-valuemin": 0,
+								"aria-valuemax": 100,
+								"aria-valuenow": itemView.progressPercent
+							}, [(0, vue.h)("div", {
+								class: "calmlens-progress__bar",
+								style: itemView.progressPercent === void 0 ? void 0 : { width: `${itemView.progressPercent}%` }
+							})]),
+							itemView.message && (0, vue.h)("p", {
+								class: "calmlens-upload__message",
+								role: "status"
+							}, itemView.message)
+						]),
+						(0, vue.h)("div", { class: "calmlens-upload__actions" }, [
+							!view.showDropzone && (0, vue.h)("button", {
+								type: "button",
+								class: "calmlens-button",
+								"data-variant": "outline",
+								"data-size": "small",
+								disabled: props.disabled,
+								onClick: openPicker
+							}, text.chooseAnother),
+							itemView.canRetry && (0, vue.h)("button", {
+								type: "button",
+								class: "calmlens-icon-button",
+								"aria-label": text.retry,
+								title: text.retry,
+								onClick: () => queue.retry(item.key)
+							}, [icon("retry")]),
+							(0, vue.h)("button", {
+								type: "button",
+								class: "calmlens-icon-button",
+								"aria-label": itemView.removeLabel,
+								title: itemView.removeLabel,
+								onClick: () => queue.remove(item.key)
+							}, [icon("remove")])
+						])
+					]);
+				}))
+			]);
+		};
+	}
+});
+/**
+* Shows an asset from the CalmLens CDN with responsive widths and a blurred placeholder while
+* it loads. Age-restricted assets stay behind the placeholder and a reveal button until
+* `ageConfirmed` is set; blocked and purged assets show an unavailable notice.
+*/
+const CalmLensMedia = (0, vue.defineComponent)({
+	name: "CalmLensMedia",
+	props: {
+		/** An asset from the API, which supplies the project, ID, status, type and preview. */
+		asset: optional(Object),
+		/** Required without `asset`. */
+		projectId: optional(String),
+		/** Required without `asset`. */
+		assetId: optional(String),
+		status: optional(String),
+		contentRemoved: optional(Boolean),
+		type: optional(String),
+		resource: optional(String),
+		lens: optional(String),
+		transform: optional([
+			String,
+			Object,
+			Array
+		]),
+		widths: optional(Array),
+		url: optional(String),
+		placeholder: {
+			type: Boolean,
+			default: true
+		},
+		placeholderHash: optional(String),
+		placeholderUrl: optional(String),
+		averageColor: optional(String),
+		cdnBaseUrl: optional(String),
+		viewerClaims: optional(Object),
+		alt: {
+			type: String,
+			default: ""
+		},
+		aspectRatio: optional(Number),
+		width: optional(Number),
+		height: optional(Number),
+		sizes: optional(String),
+		fit: optional(String),
+		position: optional(String),
+		lazy: {
+			type: Boolean,
+			default: true
+		},
+		fetchPriority: optional(String),
+		controls: {
+			type: Boolean,
+			default: true
+		},
+		messages: messagesProp,
+		/** Bound by `@reveal`; declared as a prop so the button shows only when something listens. */
+		onReveal: optional(Function)
+	},
+	setup(props) {
+		const messages = (0, vue.computed)(() => require_ui.resolveMessages(props.messages));
+		const resolved = (0, vue.computed)(() => require_ui.resolveMediaProps(props));
+		const state = (0, vue.computed)(() => require_ui.getMediaState(resolved.value));
+		const loadKey = (0, vue.computed)(() => require_ui.getMediaLoadKey(state.value));
+		const load = (0, vue.ref)("loading");
+		const image = (0, vue.ref)();
+		(0, vue.watch)(loadKey, () => {
+			load.value = "loading";
+		});
+		(0, vue.onMounted)(() => {
+			if (image.value?.complete && image.value.naturalWidth > 0) load.value = "loaded";
+		});
+		const onError = () => {
+			load.value = "error";
+		};
+		return () => {
+			const current = state.value;
+			const text = messages.value;
+			const view = resolved.value;
+			const ratio = require_ui.getMediaAspectRatio(view);
+			const failed = load.value === "error";
+			const placeholderUrl = current.kind === "audio" || current.kind === "unavailable" ? void 0 : current.placeholderUrl;
+			const showPlaceholder = placeholderUrl && (current.kind === "gated" || current.kind === "image" && load.value !== "loaded");
+			const notice = (children) => (0, vue.h)("figcaption", { class: "calmlens-media__notice" }, children);
+			return (0, vue.h)("figure", {
+				class: "calmlens-media",
+				"data-kind": current.kind,
+				"data-state": load.value,
+				"data-sized": ratio ? "" : void 0,
+				style: {
+					aspectRatio: ratio,
+					backgroundColor: view.averageColor,
+					"--calmlens-fit": props.fit,
+					"--calmlens-position": props.position
+				}
+			}, [
+				showPlaceholder && (0, vue.h)("img", {
+					class: "calmlens-media__placeholder",
+					src: placeholderUrl,
+					alt: "",
+					"aria-hidden": "true"
+				}),
+				current.kind === "image" && !failed && (0, vue.h)("img", {
+					key: loadKey.value,
+					ref: image,
+					class: "calmlens-media__content",
+					src: current.src,
+					srcset: current.srcSet,
+					sizes: props.sizes,
+					alt: props.alt,
+					width: view.width,
+					height: view.height,
+					loading: props.lazy ? "lazy" : void 0,
+					decoding: "async",
+					fetchpriority: props.fetchPriority,
+					onLoad: () => {
+						load.value = "loaded";
+					},
+					onError
+				}),
+				current.kind === "video" && !failed && (0, vue.h)("video", {
+					class: "calmlens-media__content",
+					src: current.src,
+					controls: props.controls,
+					playsinline: true,
+					preload: "metadata",
+					"aria-label": props.alt || void 0,
+					onError: () => {
+						load.value = "error";
+					}
+				}),
+				current.kind === "audio" && !failed && (0, vue.h)("audio", {
+					class: "calmlens-media__content",
+					src: current.src,
+					controls: props.controls,
+					preload: "metadata",
+					"aria-label": props.alt || void 0,
+					onError: () => {
+						load.value = "error";
+					}
+				}),
+				current.kind === "gated" && notice([
+					(0, vue.h)("strong", text.sensitiveTitle),
+					(0, vue.h)("p", text.sensitiveBody),
+					props.onReveal && (0, vue.h)("button", {
+						type: "button",
+						class: "calmlens-button",
+						onClick: props.onReveal
+					}, text.reveal)
+				]),
+				(current.kind === "unavailable" || failed) && notice([(0, vue.h)("p", [icon("unavailable"), (0, vue.h)("span", { class: "calmlens-media__label" }, require_ui.getMediaUnavailableMessage(current, text))])])
+			]);
+		};
+	}
+});
+exports.CALMLENS_STYLES = require_ui.CALMLENS_STYLES;
+exports.CALMLENS_THEME = require_ui.CALMLENS_THEME;
+exports.CalmLensMedia = CalmLensMedia;
+exports.CalmLensUploader = CalmLensUploader;
+exports.DEFAULT_MESSAGES = require_ui.DEFAULT_MESSAGES;
+exports.ICONS = require_ui.ICONS;
+exports.ICON_ATTRIBUTES = require_ui.ICON_ATTRIBUTES;
+exports.UploadController = require_UploadController.UploadController;
+exports.createProgressFetch = require_UploadController.createProgressFetch;
+exports.createUploadController = require_BrowserUpload.createUploadController;
+exports.describeUploadItem = require_ui.describeUploadItem;
+exports.describeUploader = require_ui.describeUploader;
+exports.formatBytes = require_ui.formatBytes;
+exports.formatMessage = require_ui.formatMessage;
+exports.getDropzoneHint = require_ui.getDropzoneHint;
+exports.getMediaAspectRatio = require_ui.getMediaAspectRatio;
+exports.getMediaLoadKey = require_ui.getMediaLoadKey;
+exports.getMediaState = require_ui.getMediaState;
+exports.getMediaUnavailableMessage = require_ui.getMediaUnavailableMessage;
+exports.getUploadItemMessage = require_ui.getUploadItemMessage;
+exports.getUploadItemOutcome = require_ui.getUploadItemOutcome;
+exports.isFileAccepted = require_UploadController.isFileAccepted;
+exports.pickMediaSource = require_ui.pickMediaSource;
+exports.resolveMediaProps = require_ui.resolveMediaProps;
+exports.resolveMessages = require_ui.resolveMessages;
+exports.resolveTheme = require_ui.resolveTheme;
+exports.useCalmLensUpload = useCalmLensUpload;

package/esm/BrowserUpload-D7-zNmc0.js

@@ -0,0 +1,5 @@
+import { n as createUploadController$1 } from "./UploadController-txp5NuzH.js";
+// src/ui/BrowserUpload.ts
+/** Creates an upload queue for the browser components, such as one a form starts on submit. */
+const createUploadController = (options) => createUploadController$1(options);
+export { createUploadController as t };

package/esm/BrowserUpload-uZjVFGfP.d.ts

@@ -0,0 +1,11 @@
+import { F as UploadItem$1, I as UploadSnapshot$1, M as UploadController, N as UploadControllerOptions$1, O as CalmLensUpload$1, P as UploadFile, f as UploaderProps$1 } from "./ui-CgZpgpNo.js";
+import { t as UseCalmLensUploadResult$1 } from "./ReactUpload-nZahpmyg.js";
+type UploadItem<F extends UploadFile = File> = UploadItem$1<F>;
+type CalmLensUpload<F extends UploadFile = File> = CalmLensUpload$1<F>;
+type UploadSnapshot<F extends UploadFile = File> = UploadSnapshot$1<F>;
+type UploadControllerOptions<F extends UploadFile = File> = UploadControllerOptions$1<F>;
+type UploaderProps<F extends UploadFile = File> = UploaderProps$1<F>;
+type UseCalmLensUploadResult<F extends UploadFile = File> = UseCalmLensUploadResult$1<F>;
+/** Creates an upload queue for the browser components, such as one a form starts on submit. */
+declare const createUploadController: <F extends UploadFile = File>(options: UploadControllerOptions<F>) => UploadController<F>;
+export { UploaderProps as a, UploadSnapshot as i, UploadControllerOptions as n, UseCalmLensUploadResult as o, UploadItem as r, createUploadController as s, CalmLensUpload as t };

package/esm/CalmLensAppClient-CV_K26Ce.d.ts

@@ -0,0 +1,40 @@
+import { Ct as UploadAssetPartOptions, Tt as UploadedAsset, pt as RetrieveAssetOptions, w as CalmLensAppClientOptions, wt as UploadPresetSubmitAssetOptions } from "./CalmLensTypes-9Vt16pc7.js";
+declare const inspectSymbol: unique symbol;
+/**
+ * The CalmLens client for browsers and React Native apps. It uploads through an upload preset,
+ * with an upload token from your server when the preset requires one, and never holds an API
+ * key. It can upload (`assets.create`, `assets.classify`, `assets.uploadPart`) and check its own
+ * uploads (`assets.retrieve`). Every method throws `CalmLensError` on failure.
+ */
+declare class CalmLensAppClient {
+  #private;
+  constructor(options: CalmLensAppClientOptions);
+  /** Keeps tokens out of `console.log`, `util.inspect` and `JSON.stringify`. */
+  [inspectSymbol](): string;
+  toJSON(): {
+    uploadPresetId: string;
+    baseUrl: string;
+  };
+  private get uploadsPath();
+  /** A fresh token for a new upload, when the client has one. */
+  private newUploadToken;
+  /** The `Authorization` header for an upload this client started. */
+  private authHeaders;
+  /** Uploads with a new token, kept for the upload's parts and status checks. */
+  private submit;
+  /** Uploads through the client's upload preset and checks those uploads. */
+  get assets(): {
+    /** Uploads a file and queues it for moderation. */
+    create: (options: UploadPresetSubmitAssetOptions) => Promise<UploadedAsset>;
+    /** Uploads a file and waits for its moderation decision. */
+    classify: (options: UploadPresetSubmitAssetOptions) => Promise<UploadedAsset>;
+    /**
+     * Uploads the next part of a multipart upload this client started. The upload's queue
+     * mode, chosen when it started, applies when the final part arrives.
+     */
+    uploadPart: ({ assetId, ...options }: UploadAssetPartOptions) => Promise<UploadedAsset>;
+    /** Checks an upload this client made. `status` is present when the preset shows decisions. */
+    retrieve: ({ assetId }: RetrieveAssetOptions) => Promise<UploadedAsset>;
+  };
+}
+export { CalmLensAppClient as t };

package/esm/CalmLensAppClient-FVMwrHlH.js

@@ -0,0 +1,84 @@
+import { A as invalidArgument, _ as validateAppClientOptions, j as invalidConfig, l as encodePathSegment } from "./ModerationContextLimits-D1x_WAtP.js";
+import { c as prepareSubmitAssetOptions, i as expectUploadedAsset, l as resolveConnectionOptions, t as CalmLensConnection } from "./CalmLensConnection-iyNQHA8L.js";
+// src/client/CalmLensAppClient.ts
+const inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+/**
+* The CalmLens client for browsers and React Native apps. It uploads through an upload preset,
+* with an upload token from your server when the preset requires one, and never holds an API
+* key. It can upload (`assets.create`, `assets.classify`, `assets.uploadPart`) and check its own
+* uploads (`assets.retrieve`). Every method throws `CalmLensError` on failure.
+*/
+var CalmLensAppClient = class {
+	#uploadPresetId;
+	#token;
+	/** The token each upload started with, for its parts and status checks. */
+	#uploadTokens = /* @__PURE__ */ new Map();
+	#connection;
+	constructor(options) {
+		validateAppClientOptions(options);
+		const { token, uploadPresetId, ...rest } = options;
+		this.#uploadPresetId = uploadPresetId;
+		this.#token = token;
+		this.#connection = new CalmLensConnection(resolveConnectionOptions(rest));
+	}
+	/** Keeps tokens out of `console.log`, `util.inspect` and `JSON.stringify`. */
+	[inspectSymbol]() {
+		return `CalmLensAppClient { uploadPresetId: ${JSON.stringify(this.#uploadPresetId)}, baseUrl: ${JSON.stringify(this.#connection.options.baseUrl)} }`;
+	}
+	toJSON() {
+		return {
+			uploadPresetId: this.#uploadPresetId,
+			baseUrl: this.#connection.options.baseUrl
+		};
+	}
+	get uploadsPath() {
+		return `/upload-presets/${encodeURIComponent(this.#uploadPresetId)}/assets`;
+	}
+	/** A fresh token for a new upload, when the client has one. */
+	async newUploadToken() {
+		const token = typeof this.#token === "function" ? await this.#token() : this.#token;
+		if (token !== void 0 && (typeof token !== "string" || !token)) throw invalidConfig("token must return a non-empty string");
+		return token;
+	}
+	/** The `Authorization` header for an upload this client started. */
+	authHeaders(assetId) {
+		const token = this.#uploadTokens.get(assetId);
+		return token ? { Authorization: `Bearer ${token}` } : {};
+	}
+	/** Uploads with a new token, kept for the upload's parts and status checks. */
+	async submit(options, queue) {
+		if (!options || typeof options !== "object") throw invalidArgument("Upload options are required");
+		if (!("content" in options) && !("part" in options)) throw invalidArgument("Uploads through an upload preset need content or a part");
+		prepareSubmitAssetOptions(options, { deferUploadChecks: this.#connection.deferUploadChecks });
+		const token = await this.newUploadToken();
+		const data = await this.#connection.submitRawUpload(this.uploadsPath, options, queue, token ? { Authorization: `Bearer ${token}` } : {});
+		const uploaded = expectUploadedAsset(data);
+		if (token) this.#uploadTokens.set(uploaded.id, token);
+		return uploaded;
+	}
+	/** Uploads through the client's upload preset and checks those uploads. */
+	get assets() {
+		return {
+			/** Uploads a file and queues it for moderation. */
+			create: (options) => this.submit(options, true),
+			/** Uploads a file and waits for its moderation decision. */
+			classify: (options) => this.submit(options, false),
+			/**
+			* Uploads the next part of a multipart upload this client started. The upload's queue
+			* mode, chosen when it started, applies when the final part arrives.
+			*/
+			uploadPart: async ({ assetId, ...options }) => {
+				const encodedAssetId = encodePathSegment(assetId, "Asset ID");
+				const data = await this.#connection.uploadPart(`${this.uploadsPath}/${encodedAssetId}/part`, options, this.authHeaders(assetId));
+				return expectUploadedAsset(data);
+			},
+			/** Checks an upload this client made. `status` is present when the preset shows decisions. */
+			retrieve: async ({ assetId }) => {
+				const encodedAssetId = encodePathSegment(assetId, "Asset ID");
+				const data = await this.#connection.json("GET", `${this.uploadsPath}/${encodedAssetId}`, { headers: this.authHeaders(assetId) });
+				return expectUploadedAsset(data);
+			}
+		};
+	}
+};
+export { CalmLensAppClient as t };