@powerhousedao/pieces-framework 6.2.3-dev.11

package/dist/common.js

@@ -0,0 +1,828 @@
+import { n as Property, o as assertNotNullOrUndefined, y as createAction } from "./input-COuhC1I-.js";
+import { c as isNil$1, r as tryCatchSync, s as isEmpty } from "./markdown-property-Df2l6_y_.js";
+import * as z from "zod/mini";
+import { PassThrough, Readable } from "node:stream";
+import fs from "node:fs";
+import FormData$1 from "form-data";
+
+//#region upstream/common/lib/authentication/index.ts
+let AuthenticationType = /* @__PURE__ */ function(AuthenticationType) {
+	AuthenticationType["BEARER_TOKEN"] = "BEARER_TOKEN";
+	AuthenticationType["BASIC"] = "BASIC";
+	return AuthenticationType;
+}({});
+
+//#endregion
+//#region upstream/common/lib/http/core/http-header.ts
+let HttpHeader = /* @__PURE__ */ function(HttpHeader) {
+	HttpHeader["AUTHORIZATION"] = "Authorization";
+	HttpHeader["ACCEPT"] = "Accept";
+	HttpHeader["API_KEY"] = "x-api-key";
+	HttpHeader["CONTENT_TYPE"] = "Content-Type";
+	return HttpHeader;
+}({});
+
+//#endregion
+//#region upstream/common/lib/http/core/media-type.ts
+let MediaType = /* @__PURE__ */ function(MediaType) {
+	MediaType["APPLICATION_JSON"] = "application/json";
+	MediaType["TEXT_CSV"] = "text/csv";
+	return MediaType;
+}({});
+
+//#endregion
+//#region upstream/common/lib/http/core/base-http-client.ts
+var BaseHttpClient = class {
+	constructor(baseUrl, authenticationConverter) {
+		this.baseUrl = baseUrl;
+		this.authenticationConverter = authenticationConverter;
+	}
+	getUrl(request) {
+		const url = new URL(`${this.baseUrl}${request.url}`);
+		const urlWithoutQueryParams = `${url.origin}${url.pathname}`;
+		const queryParams = new URLSearchParams();
+		url.searchParams.forEach((value, key) => {
+			queryParams.append(key, value);
+		});
+		return {
+			urlWithoutQueryParams,
+			queryParams
+		};
+	}
+	getHeaders(request) {
+		let requestHeaders = { [HttpHeader.ACCEPT]: MediaType.APPLICATION_JSON };
+		if (request.authentication) this.populateAuthentication(request.authentication, requestHeaders);
+		if (request.body) switch (request.headers?.["Content-Type"]) {
+			case "text/csv":
+				requestHeaders[HttpHeader.CONTENT_TYPE] = MediaType.TEXT_CSV;
+				break;
+			default:
+				requestHeaders[HttpHeader.CONTENT_TYPE] = MediaType.APPLICATION_JSON;
+				break;
+		}
+		if (request.headers) requestHeaders = {
+			...requestHeaders,
+			...request.headers
+		};
+		return requestHeaders;
+	}
+	populateAuthentication(authentication, headers) {
+		this.authenticationConverter.convert(authentication, headers);
+	}
+};
+
+//#endregion
+//#region upstream/common/lib/http/core/delegating-authentication-converter.ts
+var DelegatingAuthenticationConverter = class {
+	converters;
+	constructor(bearerTokenConverter = new BearerTokenAuthenticationConverter(), basicTokenConverter = new BasicTokenAuthenticationConverter()) {
+		this.converters = {
+			[AuthenticationType.BEARER_TOKEN]: bearerTokenConverter,
+			[AuthenticationType.BASIC]: basicTokenConverter
+		};
+	}
+	convert(authentication, headers) {
+		return this.converters[authentication.type].convert(authentication, headers);
+	}
+};
+var BearerTokenAuthenticationConverter = class {
+	convert(authentication, headers) {
+		headers[HttpHeader.AUTHORIZATION] = `Bearer ${authentication.token}`;
+		return headers;
+	}
+};
+var BasicTokenAuthenticationConverter = class {
+	convert(authentication, headers) {
+		const credentials = `${authentication.username}:${authentication.password}`;
+		const encoded = Buffer.from(credentials).toString("base64");
+		headers[HttpHeader.AUTHORIZATION] = `Basic ${encoded}`;
+		return headers;
+	}
+};
+
+//#endregion
+//#region upstream/common/lib/http/core/http-error.ts
+var HttpError = class extends Error {
+	status;
+	responseBody;
+	constructor(requestBody, params) {
+		const status = params.status || 500;
+		const responseBody = Buffer.isBuffer(params.responseBody) ? params.responseBody.toString() : params.responseBody;
+		super(JSON.stringify({
+			response: {
+				status,
+				body: responseBody
+			},
+			request: { body: requestBody }
+		}));
+		this.requestBody = requestBody;
+		this.status = status;
+		this.responseBody = responseBody;
+	}
+	errorMessage() {
+		return {
+			response: {
+				status: this.status,
+				body: this.responseBody
+			},
+			request: { body: this.requestBody }
+		};
+	}
+	get response() {
+		return {
+			status: this.status,
+			body: this.responseBody
+		};
+	}
+	get request() {
+		return { body: this.requestBody };
+	}
+};
+function toFailsafeOutput({ error, requestBody }) {
+	if (error instanceof HttpError) return error.errorMessage();
+	return {
+		response: {
+			status: 0,
+			body: error instanceof Error ? error.message : String(error)
+		},
+		request: { body: requestBody }
+	};
+}
+
+//#endregion
+//#region upstream/common/lib/http/core/http-method.ts
+let HttpMethod = /* @__PURE__ */ function(HttpMethod) {
+	HttpMethod["GET"] = "GET";
+	HttpMethod["POST"] = "POST";
+	HttpMethod["PATCH"] = "PATCH";
+	HttpMethod["PUT"] = "PUT";
+	HttpMethod["DELETE"] = "DELETE";
+	HttpMethod["HEAD"] = "HEAD";
+	return HttpMethod;
+}({});
+
+//#endregion
+//#region upstream/common/lib/http/core/fetch-http-client.ts
+var FetchHttpClient = class extends BaseHttpClient {
+	constructor(baseUrl = "", authenticationConverter = new DelegatingAuthenticationConverter()) {
+		super(baseUrl, authenticationConverter);
+	}
+	async sendRequest(request, options) {
+		const { urlWithoutQueryParams, queryParams: urlQueryParams } = this.getUrl(request);
+		const headers = this.getHeaders(request);
+		const queryParams = request.queryParams ?? {};
+		for (const [key, value] of Object.entries(queryParams)) urlQueryParams.append(key, value);
+		const queryString = urlQueryParams.toString();
+		const finalUrl = queryString ? `${urlWithoutQueryParams}?${queryString}` : urlWithoutQueryParams;
+		const responseType = request.responseType ?? "json";
+		const followRedirects = request.followRedirects ?? true;
+		const retries = request.retries ?? 0;
+		const { body, extraHeaders, isStream } = acceptsRequestBody(request.method) ? serializeBody(request.body, headers) : {
+			body: void 0,
+			extraHeaders: {},
+			isStream: false
+		};
+		const finalHeaders = normalizeHeaders({
+			...headers,
+			...extraHeaders
+		});
+		const response = await sendWithRetries(async () => {
+			const controller = new AbortController();
+			const timeoutId = request.timeout && request.timeout > 0 ? setTimeout(() => controller.abort(), request.timeout) : void 0;
+			try {
+				const init = {
+					method: request.method.toString(),
+					headers: finalHeaders,
+					body,
+					redirect: followRedirects ? "follow" : "manual",
+					signal: controller.signal
+				};
+				if (isStream) init.duplex = "half";
+				if (options?.dispatcher !== void 0) init.dispatcher = options.dispatcher;
+				return await fetch(finalUrl, init);
+			} finally {
+				if (timeoutId !== void 0) clearTimeout(timeoutId);
+			}
+		}, isStream ? 0 : retries);
+		const successCeiling = followRedirects ? 300 : 400;
+		if (response.status < 200 || response.status >= successCeiling) {
+			const errorBody = await parseResponseBody(response, responseType === "stream" ? "text" : responseType);
+			throw new HttpError(request.body, {
+				status: response.status,
+				responseBody: errorBody
+			});
+		}
+		const responseBody = await parseResponseBody(response, responseType);
+		return {
+			status: response.status,
+			headers: toHttpHeaders(response.headers),
+			body: responseBody
+		};
+	}
+};
+function acceptsRequestBody(method) {
+	return method !== HttpMethod.GET && method !== HttpMethod.HEAD;
+}
+function serializeBody(body, headers) {
+	if (isNil(body)) return {
+		body: void 0,
+		extraHeaders: {},
+		isStream: false
+	};
+	if (isNodeFormData(body)) {
+		const buffered = bufferFormDataIfSafe(body);
+		if (buffered !== null) return {
+			body: buffered,
+			extraHeaders: body.getHeaders(),
+			isStream: false
+		};
+		const stream = new PassThrough();
+		body.on("error", (error) => stream.destroy(error));
+		body.pipe(stream);
+		return {
+			body: stream,
+			extraHeaders: body.getHeaders(),
+			isStream: true
+		};
+	}
+	if (body instanceof Readable) return {
+		body,
+		extraHeaders: {},
+		isStream: true
+	};
+	if (typeof body === "string" || Buffer.isBuffer(body) || body instanceof URLSearchParams || body instanceof ArrayBuffer || typeof FormData !== "undefined" && body instanceof FormData || typeof Blob !== "undefined" && body instanceof Blob) return {
+		body,
+		extraHeaders: {},
+		isStream: false
+	};
+	if ((headers["Content-Type"] ?? headers["content-type"] ?? "").includes("application/x-www-form-urlencoded")) return {
+		body: new URLSearchParams(body).toString(),
+		extraHeaders: {},
+		isStream: false
+	};
+	return {
+		body: JSON.stringify(body),
+		extraHeaders: {},
+		isStream: false
+	};
+}
+async function parseResponseBody(response, responseType) {
+	switch (responseType) {
+		case "arraybuffer": return Buffer.from(await response.arrayBuffer());
+		case "stream": return isNil(response.body) ? Readable.from([]) : Readable.fromWeb(response.body);
+		case "blob": return await response.blob();
+		case "text": return await response.text();
+		default: {
+			const text = await response.text();
+			if (text.length === 0) return;
+			try {
+				return JSON.parse(text);
+			} catch {
+				return text;
+			}
+		}
+	}
+}
+async function sendWithRetries(fn, retries) {
+	let lastError;
+	for (let attempt = 0; attempt <= retries; attempt++) try {
+		const response = await fn();
+		if (response.status >= 500 && attempt < retries) {
+			await backoff(attempt);
+			continue;
+		}
+		return response;
+	} catch (error) {
+		lastError = error;
+		if (attempt < retries) {
+			await backoff(attempt);
+			continue;
+		}
+		throw error;
+	}
+	throw lastError;
+}
+function backoff(attempt) {
+	const delayMs = Math.min(1e3 * 2 ** attempt, 3e4);
+	return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function normalizeHeaders(headers) {
+	const entriesByLowerCaseKey = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		entriesByLowerCaseKey.set(key.toLowerCase(), [key, Array.isArray(value) ? value.join(", ") : value]);
+	}
+	return Object.fromEntries(entriesByLowerCaseKey.values());
+}
+function toHttpHeaders(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+function bufferFormDataIfSafe(body) {
+	if (!body.hasKnownLength() || body.getLengthSync() > MAX_BUFFERED_FORM_DATA_BYTES) return null;
+	const { data } = tryCatchSync(() => body.getBuffer());
+	return data;
+}
+function isNodeFormData(body) {
+	return typeof body === "object" && body !== null && typeof body.getHeaders === "function" && typeof body.pipe === "function" && typeof body.on === "function";
+}
+function isNil(value) {
+	return value === null || value === void 0;
+}
+const MAX_BUFFERED_FORM_DATA_BYTES = 100 * 1024 * 1024;
+
+//#endregion
+//#region upstream/common/lib/http/core/http-client.ts
+const httpClient = new FetchHttpClient();
+
+//#endregion
+//#region upstream/common/lib/helpers/index.ts
+const CONTENT_TYPE_EXTENSIONS = {
+	"application/json": "json",
+	"application/pdf": "pdf",
+	"application/xml": "xml",
+	"text/xml": "xml",
+	"application/zip": "zip",
+	"application/gzip": "gz",
+	"application/x-tar": "tar",
+	"application/octet-stream": "bin",
+	"application/msword": "doc",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+	"application/vnd.ms-excel": "xls",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+	"application/vnd.ms-powerpoint": "ppt",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+	"application/rtf": "rtf",
+	"application/javascript": "js",
+	"application/x-www-form-urlencoded": "bin",
+	"text/plain": "txt",
+	"text/html": "html",
+	"text/css": "css",
+	"text/csv": "csv",
+	"text/calendar": "ics",
+	"text/markdown": "md",
+	"image/png": "png",
+	"image/jpeg": "jpeg",
+	"image/jpg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"image/svg+xml": "svg",
+	"image/bmp": "bmp",
+	"image/tiff": "tiff",
+	"image/x-icon": "ico",
+	"image/vnd.microsoft.icon": "ico",
+	"image/heic": "heic",
+	"audio/mpeg": "mp3",
+	"audio/mp4": "m4a",
+	"audio/wav": "wav",
+	"audio/x-wav": "wav",
+	"audio/ogg": "ogg",
+	"audio/webm": "weba",
+	"video/mp4": "mp4",
+	"video/mpeg": "mpeg",
+	"video/webm": "webm",
+	"video/quicktime": "mov",
+	"video/x-msvideo": "avi",
+	"font/woff": "woff",
+	"font/woff2": "woff2",
+	"font/ttf": "ttf",
+	"font/otf": "otf"
+};
+function contentTypeToExtension(contentType) {
+	return CONTENT_TYPE_EXTENSIONS[contentType.split(";")[0].trim().toLowerCase()] ?? "";
+}
+const getAccessTokenOrThrow = (auth) => {
+	const accessToken = auth?.access_token;
+	if (accessToken === void 0) throw new Error("Invalid bearer token");
+	return accessToken;
+};
+const joinBaseUrlWithRelativePath = ({ baseUrl, relativePath }) => {
+	return `${baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`}${relativePath.startsWith("/") ? relativePath.slice(1) : relativePath}`;
+};
+const getBaseUrlForDescription = (baseUrl, auth) => {
+	const exampleBaseUrl = `https://api.example.com`;
+	try {
+		const baseUrlValue = auth ? baseUrl(auth) : void 0;
+		return (baseUrlValue?.endsWith("/") ? baseUrlValue.slice(0, -1) : baseUrlValue) ?? exampleBaseUrl;
+	} catch (error) {
+		return exampleBaseUrl;
+	}
+};
+function createCustomApiCallAction({ auth, baseUrl, authMapping, description, displayName, name, props, extraProps, authLocation = "headers", classification = "WRITE" }) {
+	return createAction({
+		audience: "human",
+		name: name ? name : "custom_api_call",
+		classification,
+		displayName: displayName ? displayName : "Custom API Call",
+		description: description ? description : "Make a custom API call to a specific endpoint",
+		auth,
+		requireAuth: auth ? true : false,
+		props: {
+			url: Property.DynamicProperties({
+				auth,
+				displayName: "",
+				required: true,
+				refreshers: [],
+				props: async ({ auth }) => {
+					return { url: Property.ShortText({
+						displayName: "URL",
+						description: `Full URL, or a path relative to ${getBaseUrlForDescription(baseUrl, auth)}`,
+						required: true,
+						placeholder: "/resource",
+						defaultValue: auth ? baseUrl(auth) : "",
+						...props?.url ?? {}
+					}) };
+				}
+			}),
+			method: Property.StaticDropdown({
+				displayName: "Method",
+				required: true,
+				defaultValue: HttpMethod.GET,
+				options: { options: Object.values(HttpMethod).map((v) => {
+					return {
+						label: v,
+						value: v
+					};
+				}) },
+				...props?.method ?? {}
+			}),
+			headers: Property.Object({
+				displayName: "Headers",
+				description: "Authorization headers are injected automatically from your connection.",
+				required: false,
+				...props?.headers ?? {}
+			}),
+			queryParams: Property.Object({
+				displayName: "Query Parameters",
+				description: "Appended to the URL as ?key=value.",
+				required: false,
+				...props?.queryParams ?? {}
+			}),
+			body_type: Property.Dropdown({
+				auth,
+				displayName: "Body Type",
+				required: false,
+				defaultValue: "none",
+				refreshers: ["method"],
+				options: async ({ method }) => {
+					if (!acceptsRequestBody(method)) return {
+						disabled: true,
+						placeholder: "Not available for GET or HEAD requests",
+						options: []
+					};
+					return {
+						disabled: false,
+						options: [
+							{
+								label: "None",
+								value: "none"
+							},
+							{
+								label: "JSON",
+								value: "json"
+							},
+							{
+								label: "Form Data",
+								value: "form_data"
+							},
+							{
+								label: "Raw",
+								value: "raw"
+							}
+						]
+					};
+				}
+			}),
+			body: Property.DynamicProperties({
+				auth,
+				displayName: "Body",
+				refreshers: ["body_type", "method"],
+				required: false,
+				props: async ({ body_type, method }) => {
+					if (!body_type || !acceptsRequestBody(method)) return {};
+					const bodyTypeInput = body_type;
+					const fields = {};
+					switch (bodyTypeInput) {
+						case "none": break;
+						case "json":
+							fields["data"] = Property.Json({
+								displayName: "JSON Body",
+								required: true,
+								...props?.body ?? {}
+							});
+							break;
+						case "raw":
+							fields["data"] = Property.LongText({
+								displayName: "Raw Body",
+								required: true
+							});
+							break;
+						case "form_data":
+							fields["data"] = Property.Array({
+								displayName: "Form Data",
+								required: true,
+								properties: {
+									fieldName: Property.ShortText({
+										displayName: "Field Name",
+										required: true
+									}),
+									fieldType: Property.StaticDropdown({
+										displayName: "Field Type",
+										required: true,
+										options: {
+											disabled: false,
+											options: [{
+												label: "Text",
+												value: "text"
+											}, {
+												label: "File",
+												value: "file"
+											}]
+										}
+									}),
+									textFieldValue: Property.LongText({
+										displayName: "Text Field Value",
+										required: false
+									}),
+									fileFieldValue: Property.File({
+										displayName: "File Field Value",
+										required: false
+									})
+								}
+							});
+							break;
+					}
+					return fields;
+				}
+			}),
+			response_is_binary: Property.Checkbox({
+				displayName: "Response is Binary",
+				description: "Enable for files like PDFs, images, etc.",
+				required: false,
+				defaultValue: false,
+				advanced: true,
+				...props?.response_is_binary ?? {}
+			}),
+			failsafe: Property.Checkbox({
+				displayName: "Return Error as Output",
+				description: "On a failed request, output the error instead of failing the step.",
+				required: false,
+				advanced: true,
+				...props?.failsafe ?? {}
+			}),
+			timeout: Property.Number({
+				displayName: "Timeout",
+				description: "Seconds to wait for a response. Empty: up to the flow limit (10 min).",
+				required: false,
+				advanced: true,
+				...props?.timeout ?? {}
+			}),
+			followRedirects: Property.Checkbox({
+				displayName: "Follow redirects",
+				description: "Follow 3xx redirects instead of returning them as the response.",
+				required: false,
+				defaultValue: false,
+				advanced: true,
+				...props?.followRedirects ?? {}
+			}),
+			...extraProps
+		},
+		run: async (context) => {
+			const { method, url, headers, queryParams, body, body_type, failsafe, timeout, response_is_binary, followRedirects } = context.propsValue;
+			assertNotNullOrUndefined(method, "Method");
+			assertNotNullOrUndefined(url, "URL");
+			const authValue = !isNil$1(authMapping) ? await authMapping(context.auth, context.propsValue) : {};
+			const urlValue = url["url"];
+			const request = {
+				method,
+				url: urlValue.startsWith("http://") || urlValue.startsWith("https://") ? urlValue : joinBaseUrlWithRelativePath({
+					baseUrl: baseUrl(context.auth),
+					relativePath: urlValue
+				}),
+				headers: {
+					...headers ?? {},
+					...authLocation === "headers" ? authValue : {}
+				},
+				queryParams: {
+					...authLocation === "queryParams" ? authValue : {},
+					...queryParams ?? {}
+				},
+				timeout: timeout ? timeout * 1e3 : 0,
+				followRedirects
+			};
+			if (response_is_binary) request.responseType = "arraybuffer";
+			if (body) {
+				if (body_type && body_type !== "none") {
+					const bodyInput = body["data"];
+					if (body_type === "form_data") {
+						const formBodyInput = bodyInput;
+						const formData = new FormData$1();
+						for (const { fieldName, fieldType, textFieldValue, fileFieldValue } of formBodyInput) if (fieldType === "text" && !isEmpty(textFieldValue)) formData.append(fieldName, textFieldValue);
+						else if (fieldType === "file" && !isEmpty(fileFieldValue)) formData.append(fieldName, fileFieldValue.data, { filename: fileFieldValue?.filename });
+						request.body = formData;
+						request.headers = {
+							...request.headers,
+							...formData.getHeaders()
+						};
+					} else request.body = bodyInput;
+				} else if (!body_type) request.body = body;
+			}
+			try {
+				const response = await httpClient.sendRequest(request);
+				return await handleBinaryResponse(context.files, response.body, response.status, response.headers, response_is_binary);
+			} catch (error) {
+				if (failsafe) return toFailsafeOutput({
+					error,
+					requestBody: request.body
+				});
+				throw error;
+			}
+		}
+	});
+}
+function is_chromium_installed() {
+	return fs.existsSync("/usr/bin/chromium");
+}
+const handleBinaryResponse = async (files, bodyContent, status, headers, isBinary) => {
+	let body;
+	if (isBinary && isBinaryBody(bodyContent)) {
+		const fileExtension = contentTypeToExtension((Array.isArray(headers?.["content-type"]) ? headers["content-type"][0] : headers?.["content-type"]) ?? "") || "txt";
+		let bufferData;
+		if (bodyContent instanceof ArrayBuffer) bufferData = Buffer.from(new Uint8Array(bodyContent));
+		else if (Buffer.isBuffer(bodyContent)) bufferData = bodyContent;
+		else bufferData = Buffer.from(bodyContent);
+		body = await files.write({
+			fileName: `output.${fileExtension}`,
+			data: bufferData
+		});
+	} else body = bodyContent;
+	return {
+		status,
+		headers,
+		body
+	};
+};
+const isBinaryBody = (body) => {
+	return body instanceof ArrayBuffer || Buffer.isBuffer(body);
+};
+
+//#endregion
+//#region upstream/common/lib/polling/index.ts
+let DedupeStrategy = /* @__PURE__ */ function(DedupeStrategy) {
+	DedupeStrategy[DedupeStrategy["TIMEBASED"] = 0] = "TIMEBASED";
+	DedupeStrategy[DedupeStrategy["LAST_ITEM"] = 1] = "LAST_ITEM";
+	return DedupeStrategy;
+}({});
+const pollingHelper = {
+	async poll(polling, { store, auth, propsValue, maxItemsToPoll, files, server }) {
+		switch (polling.strategy) {
+			case DedupeStrategy.TIMEBASED: {
+				const lastEpochMilliSeconds = await store.get("lastPoll");
+				if (isNil$1(lastEpochMilliSeconds)) throw new Error("lastPoll doesn't exist in the store.");
+				const items = await polling.items({
+					store,
+					auth,
+					propsValue,
+					lastFetchEpochMS: lastEpochMilliSeconds,
+					server
+				});
+				const newLastEpochMilliSeconds = items.reduce((acc, item) => Math.max(acc, item.epochMilliSeconds), lastEpochMilliSeconds);
+				await store.put("lastPoll", newLastEpochMilliSeconds);
+				return items.filter((f) => f.epochMilliSeconds > lastEpochMilliSeconds).map((item) => item.data);
+			}
+			case DedupeStrategy.LAST_ITEM: {
+				const lastItemId = await store.get("lastItem");
+				const items = await polling.items({
+					store,
+					auth,
+					propsValue,
+					lastItemId,
+					files,
+					server
+				});
+				const lastItemIndex = items.findIndex((f) => f.id === lastItemId);
+				let newItems = [];
+				if (isNil$1(lastItemId) || lastItemIndex == -1) newItems = items ?? [];
+				else newItems = items?.slice(0, lastItemIndex) ?? [];
+				if (!isNil$1(maxItemsToPoll)) newItems = newItems.slice(-maxItemsToPoll);
+				const newLastItem = newItems?.[0]?.id;
+				if (!isNil$1(newLastItem)) await store.put("lastItem", newLastItem);
+				return newItems.map((item) => item.data);
+			}
+		}
+	},
+	async onEnable(polling, { store, auth, propsValue, server, isRepublish }) {
+		switch (polling.strategy) {
+			case DedupeStrategy.TIMEBASED:
+				if (isRepublish && !isNil$1(await store.get("lastPoll"))) break;
+				await store.put("lastPoll", Date.now());
+				break;
+			case DedupeStrategy.LAST_ITEM: {
+				if (isRepublish && !isNil$1(await store.get("lastItem"))) break;
+				const lastItemId = (await polling.items({
+					store,
+					auth,
+					propsValue,
+					lastItemId: null,
+					server
+				}))?.[0]?.id;
+				if (!isNil$1(lastItemId)) await store.put("lastItem", lastItemId);
+				else await store.delete("lastItem");
+				break;
+			}
+		}
+	},
+	async onDisable(polling, params) {
+		switch (polling.strategy) {
+			case DedupeStrategy.TIMEBASED:
+			case DedupeStrategy.LAST_ITEM: return;
+		}
+	},
+	async test(polling, { auth, propsValue, store, files, server }) {
+		let items = [];
+		switch (polling.strategy) {
+			case DedupeStrategy.TIMEBASED:
+				items = await polling.items({
+					store,
+					auth,
+					propsValue,
+					lastFetchEpochMS: 0,
+					server
+				});
+				break;
+			case DedupeStrategy.LAST_ITEM:
+				items = await polling.items({
+					store,
+					auth,
+					propsValue,
+					lastItemId: null,
+					files,
+					server
+				});
+				break;
+		}
+		return getFirstFiveOrAll(items.map((item) => item.data));
+	}
+};
+function getFirstFiveOrAll(array) {
+	if (array.length <= 5) return array;
+	else return array.slice(0, 5);
+}
+
+//#endregion
+//#region upstream/common/lib/stream/index.ts
+function toStreamingBody(file) {
+	if ("body" in file) return {
+		body: file.body,
+		size: file.size
+	};
+	return {
+		body: Readable.from(file.data),
+		size: file.data.length
+	};
+}
+async function* readChunks({ readable, chunkSize }) {
+	let pending = [];
+	let pendingLength = 0;
+	if (!Number.isInteger(chunkSize) || chunkSize <= 0) throw new Error("chunkSize must be a positive integer");
+	for await (const data of readable) {
+		pending.push(Buffer.isBuffer(data) ? data : Buffer.from(data));
+		pendingLength += pending[pending.length - 1].length;
+		while (pendingLength >= chunkSize) {
+			const combined = pending.length === 1 ? pending[0] : Buffer.concat(pending);
+			yield combined.subarray(0, chunkSize);
+			const rest = combined.subarray(chunkSize);
+			pending = rest.length > 0 ? [rest] : [];
+			pendingLength = rest.length;
+		}
+	}
+	if (pendingLength > 0) yield pending.length === 1 ? pending[0] : Buffer.concat(pending);
+}
+const streamUtils = {
+	readChunks,
+	toStreamingBody
+};
+
+//#endregion
+//#region upstream/common/lib/validation/index.ts
+const propsValidation = { async validateZod(props, schema) {
+	const schemaObj = z.object(Object.entries(schema).reduce((acc, [key, value]) => ({
+		...acc,
+		[key]: value
+	}), {}));
+	const result = await z.safeParseAsync(schemaObj, props);
+	if (!result.success) {
+		const errors = result.error.issues.reduce((acc, issue) => ({
+			...acc,
+			[issue.path.join(".")]: issue.message
+		}), {});
+		throw new Error(JSON.stringify({ errors }, null, 2));
+	}
+} };
+
+//#endregion
+export { AuthenticationType, FetchHttpClient as AxiosHttpClient, FetchHttpClient, BaseHttpClient, DedupeStrategy, DelegatingAuthenticationConverter, HttpError, HttpHeader, HttpMethod, MediaType, acceptsRequestBody, createCustomApiCallAction, getAccessTokenOrThrow, httpClient, is_chromium_installed, pollingHelper, propsValidation, streamUtils, toFailsafeOutput };
+//# sourceMappingURL=common.js.map