@8ms/helpers 2.3.26 → 2.3.27

package/dist/getDecimal-CafxtLhH.mjs

@@ -0,0 +1,40 @@
+import { isJson } from "./json/index.mjs";
+
+//#region src/number/getNumber.ts
+/**
+* Take an input and return a number.
+*/
+const getNumber = (input, defaultValue = 0) => {
+	if (input == null) return defaultValue;
+	let response = input;
+	if (typeof input === "string" && isJson(input)) try {
+		response = JSON.parse(input);
+	} catch {
+		response = input;
+	}
+	if (typeof response === "number") return isNaN(response) ? defaultValue : response;
+	if (typeof response === "string") {
+		const directConversion = Number(response.trim());
+		if (!isNaN(directConversion)) return directConversion;
+		const match = response.match(/^\D*([0-9]*\.?[0-9]+)\D*$/);
+		if (match && match[1]) {
+			const extracted = Number(match[1]);
+			if (!isNaN(extracted)) return extracted;
+		}
+	}
+	const converted = Number(response);
+	return isNaN(converted) ? defaultValue : converted;
+};
+
+//#endregion
+//#region src/number/getDecimal.ts
+/**
+* Return a decimal number after rounding.
+*/
+const getDecimal = (input, dp = 2) => {
+	const number = getNumber(input);
+	return Number(number.toFixed(dp));
+};
+
+//#endregion
+export { getNumber as n, getDecimal as t };

package/dist/googleAds/keywordPlanner/server/index.d.mts

@@ -0,0 +1,45 @@
+import { z } from "zod/v4";
+
+//#region src/googleAds/keywordPlanner/server/googleAdsKeywordPlanner.d.ts
+declare const network: {
+  readonly GOOGLE_SEARCH_ONLY: 2;
+  readonly GOOGLE_SEARCH_AND_PARTNERS: 3;
+};
+type Network = typeof network[keyof typeof network];
+declare const requestSchema: z.ZodObject<{
+  countries: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  customerId: z.ZodOptional<z.ZodString>;
+  historicalMetricsOptions: z.ZodOptional<z.ZodObject<{
+    startMonth: z.ZodString;
+    startYear: z.ZodNumber;
+    endMonth: z.ZodString;
+    endYear: z.ZodNumber;
+  }, z.core.$strip>>;
+  includeAdultKeywords: z.ZodOptional<z.ZodBoolean>;
+  keywordPlanNetwork: z.ZodOptional<z.ZodNumber>;
+  queries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  language: z.ZodOptional<z.ZodNumber>;
+  url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RequestSchemaType = z.infer<typeof requestSchema>;
+declare const defaultRequest: RequestSchemaType;
+declare const responseSchema: z.ZodObject<{
+  payload: z.ZodObject<{}, z.core.$strip>;
+  keyword: z.ZodString;
+  avgCpc: z.ZodNumber;
+  avgSearchVolume: z.ZodNumber;
+  competition: z.ZodNumber;
+  competitionIndex: z.ZodNumber;
+  months: z.ZodArray<z.ZodObject<{
+    date: z.ZodString;
+    month: z.ZodNumber;
+    searchVolume: z.ZodNumber;
+    year: z.ZodNumber;
+  }, z.core.$strip>>;
+  topOfPageBidHigh: z.ZodNumber;
+  topOfPageBidLow: z.ZodNumber;
+  totalSearchVolume: z.ZodNumber;
+}, z.core.$strip>;
+type ResponseSchemaType = z.infer<typeof responseSchema>;
+//#endregion
+export { Network, RequestSchemaType, ResponseSchemaType, defaultRequest, network, requestSchema, responseSchema };

package/dist/googleAds/keywordPlanner/server/index.mjs

@@ -0,0 +1,51 @@
+import { z } from "zod/v4";
+
+//#region src/googleAds/keywordPlanner/server/googleAdsKeywordPlanner.ts
+const network = {
+	GOOGLE_SEARCH_ONLY: 2,
+	GOOGLE_SEARCH_AND_PARTNERS: 3
+};
+const requestSchema = z.object({
+	countries: z.array(z.number()).optional(),
+	customerId: z.string().optional(),
+	historicalMetricsOptions: z.object({
+		startMonth: z.string(),
+		startYear: z.number(),
+		endMonth: z.string(),
+		endYear: z.number()
+	}).optional(),
+	includeAdultKeywords: z.boolean().optional(),
+	keywordPlanNetwork: z.number().optional(),
+	queries: z.array(z.string()).optional(),
+	language: z.number().optional(),
+	url: z.string().optional()
+});
+const defaultRequest = {
+	countries: [],
+	customerId: "",
+	historicalMetricsOptions: null,
+	includeAdultKeywords: false,
+	keywordPlanNetwork: network.GOOGLE_SEARCH_ONLY,
+	queries: [],
+	language: null
+};
+const responseSchema = z.object({
+	payload: z.object(),
+	keyword: z.string(),
+	avgCpc: z.number(),
+	avgSearchVolume: z.number(),
+	competition: z.number(),
+	competitionIndex: z.number(),
+	months: z.object({
+		date: z.string(),
+		month: z.number(),
+		searchVolume: z.number(),
+		year: z.number()
+	}).array(),
+	topOfPageBidHigh: z.number(),
+	topOfPageBidLow: z.number(),
+	totalSearchVolume: z.number()
+});
+
+//#endregion
+export { defaultRequest, network, requestSchema, responseSchema };

package/dist/googleAds/server/index.d.mts

@@ -0,0 +1,27 @@
+import { t as BaseNamespace } from "../../index-DwB8X1lz.mjs";
+import * as google_ads_api0 from "google-ads-api";
+import { GoogleAdsApi } from "google-ads-api";
+
+//#region src/googleAds/server/GoogleAdsNamespace.d.ts
+declare class GoogleAdsNamespace extends BaseNamespace {
+  client: GoogleAdsApi;
+  config: Config;
+  mccAccountId: string;
+  refreshToken: string;
+  ensureInit: () => Promise<void>;
+  getCustomer: (customerId: string) => Promise<google_ads_api0.Customer>;
+}
+//#endregion
+//#region src/googleAds/server/googleAds.d.ts
+type Config = {
+  client: {
+    clientId: string;
+    clientSecret: string;
+    developerToken: string;
+  };
+  mccAccountId: string;
+  refreshToken: string;
+};
+declare const googleAdsClient: (key?: string, config?: Config, vaultId?: string, itemId?: string) => Promise<GoogleAdsNamespace>;
+//#endregion
+export { Config, GoogleAdsNamespace, googleAdsClient };

package/dist/googleAds/server/index.mjs

@@ -0,0 +1,48 @@
+import { BaseNamespace } from "../../_class/index.mjs";
+import { onePasswordClient } from "../../onePassword/server/index.mjs";
+
+//#region src/googleAds/server/GoogleAdsNamespace.ts
+var GoogleAdsNamespace = class extends BaseNamespace {
+	mccAccountId = "";
+	refreshToken = "";
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { GoogleAdsApi } = await import("google-ads-api");
+			this.client = new GoogleAdsApi({
+				client_id: this.config.client.clientId,
+				client_secret: this.config.client.clientSecret,
+				developer_token: this.config.client.developerToken
+			});
+			this.mccAccountId = this.config.mccAccountId;
+			this.refreshToken = this.config.refreshToken;
+		} catch (e) {
+			throw new Error("Google Sheets Client not installed");
+		}
+	};
+	getCustomer = async (customerId) => {
+		await this.ensureInit();
+		return this.client.Customer({
+			customer_id: customerId,
+			login_customer_id: this.mccAccountId,
+			refresh_token: this.refreshToken
+		});
+	};
+};
+
+//#endregion
+//#region src/googleAds/server/googleAds.ts
+const googleAdsNamespaces = /* @__PURE__ */ new Map();
+const googleAdsClient = async (key = "default", config, vaultId, itemId) => {
+	if (googleAdsNamespaces.has(key)) return googleAdsNamespaces.get(key);
+	let instanceConfig;
+	if (config) instanceConfig = config;
+	else if (vaultId && itemId) instanceConfig = await (await onePasswordClient()).getJsonNote(vaultId, itemId);
+	else if (process.env.GOOGLE_ADS_VAULT_ID && process.env.GOOGLE_ADS_ITEM_ID) instanceConfig = await (await onePasswordClient()).getJsonNote(process.env.GOOGLE_ADS_VAULT_ID, process.env.GOOGLE_ADS_ITEM_ID);
+	else throw new Error(`Config required for namespace '${key}'`);
+	const namespace = new GoogleAdsNamespace(key, instanceConfig);
+	googleAdsNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { GoogleAdsNamespace, googleAdsClient };

package/dist/googleCloud/bigquery/server/index.d.mts

@@ -0,0 +1,82 @@
+import { t as BaseNamespace } from "../../../index-DwB8X1lz.mjs";
+import { t as GoogleCloudConfig } from "../../../index-DmCSxHCc.mjs";
+import { BigQuery, DatasetResource, QueryOptions } from "@google-cloud/bigquery";
+import { GoogleAuthOptions } from "@google-cloud/common";
+
+//#region src/googleCloud/bigquery/server/GoogleCloudBigqueryNamespace.d.ts
+type QueryInput = string | {
+  query: string;
+  location?: string;
+  params: QueryOptions;
+};
+type Dataset = {
+  id: string;
+  location: string;
+  projectId: string;
+};
+type Table = {
+  id: string;
+};
+declare class GoogleCloudBigqueryNamespace extends BaseNamespace {
+  client: BigQuery;
+  config: GoogleCloudConfig & {
+    projectId?: string;
+  };
+  ensureInit: () => Promise<void>;
+  /**
+   * Create a Dataset if it doesn't already exist.
+   * Returns table instance.
+   */
+  createDataset: (datasetId: string, options?: DatasetResource) => Promise<void>;
+  /**
+   * Check to see whether a given Bigquery dataset exists.
+   * Based off:
+   * https://github.com/googleapis/nodejs-bigquery/blob/main/samples/getDataset.js
+   */
+  datasetExists: (datasetId: string) => Promise<any>;
+  /**
+   * Retrieve all the Datasets
+   */
+  getDatasets: () => Promise<Dataset[]>;
+  query: (props: QueryInput) => Promise<any>;
+  /**
+   * Create a Table if it doesn't already exist.
+   */
+  createTable: (datasetId: string, datasetOptions: object, tableId: string, options?: object) => Promise<void>;
+  /**
+   * Check to see whether a given BigQuery table exists.
+   * https://cloud.google.com/bigquery/docs/samples/bigquery-table-exists
+   */
+  tableExists: (datasetId: string, tableId: string) => Promise<boolean>;
+  getTables: (datasetId: string) => Promise<Table[]>;
+}
+//#endregion
+//#region src/googleCloud/bigquery/server/googleCloudBigquery.d.ts
+declare const googleCloudBigqueryClient$1: (key?: string, projectId?: string, config?: GoogleAuthOptions, vaultId?: string, itemId?: string) => Promise<GoogleCloudBigqueryNamespace>;
+declare const getHandlerPath: (input: string) => string;
+//#endregion
+//#region src/googleCloud/bigquery/server/loadData.d.ts
+type LoadData = {
+  googleCloudBigqueryClient: GoogleCloudBigqueryNamespace;
+  googleCloudStorageClient: any;
+  file: {
+    bucket: string;
+    key: string;
+    metadata: object;
+  };
+  table: {
+    datasetId: string;
+    tableId: string;
+  };
+};
+/**
+ * Load data into a given table using Google Cloud Storage.
+ */
+declare const loadData: ({
+  file,
+  googleCloudBigqueryClient,
+  googleCloudStorageClient,
+  table
+}: LoadData) => Promise<void>;
+//#endregion
+export { type GoogleCloudBigqueryNamespace, QueryInput, getHandlerPath, googleCloudBigqueryClient$1 as googleCloudBigqueryClient, loadData };

package/dist/googleCloud/bigquery/server/index.mjs

@@ -0,0 +1,133 @@
+import { isObject } from "../../../lodash/index.mjs";
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { onePasswordClient } from "../../../onePassword/server/index.mjs";
+import { getConfig } from "../../server/index.mjs";
+
+//#region src/googleCloud/bigquery/server/GoogleCloudBigqueryNamespace.ts
+var GoogleCloudBigqueryNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { BigQuery } = await import("@google-cloud/bigquery");
+			this.client = new BigQuery(getConfig(this.config, this.config?.projectId));
+		} catch (e) {
+			throw new Error("Google BigQuery Client not installed");
+		}
+	};
+	/**
+	* Create a Dataset if it doesn't already exist.
+	* Returns table instance.
+	*/
+	createDataset = async (datasetId, options = {}) => {
+		await this.ensureInit();
+		if (!await this.datasetExists(datasetId)) await this.client.createDataset(datasetId);
+	};
+	/**
+	* Check to see whether a given Bigquery dataset exists.
+	* Based off:
+	* https://github.com/googleapis/nodejs-bigquery/blob/main/samples/getDataset.js
+	*/
+	datasetExists = async (datasetId) => {
+		await this.ensureInit();
+		let response;
+		try {
+			await this.client.dataset(datasetId).get();
+			response = true;
+		} catch (exception) {
+			response = false;
+		}
+		return response;
+	};
+	/**
+	* Retrieve all the Datasets
+	*/
+	getDatasets = async () => {
+		await this.ensureInit();
+		let response = [];
+		const datasets = await this.client.getDatasets();
+		if (datasets?.[0]) for (let i = 0; i < datasets[0].length; i++) response.push({
+			id: datasets[0][i].id,
+			location: datasets[0][i].location,
+			projectId: datasets[0][i].bigQuery.projectId
+		});
+		return response;
+	};
+	query = async (props) => {
+		await this.ensureInit();
+		let options = { query: "" };
+		if ("string" === props) options.query = props;
+		else if (isObject(props)) {
+			options.query = props.query;
+			if (props?.location) options["location"] = props.location;
+			if (props?.params) options["params"] = props.params;
+		}
+		return await this.client.query(options);
+	};
+	/**
+	* Create a Table if it doesn't already exist.
+	*/
+	createTable = async (datasetId, datasetOptions = {}, tableId, options = {}) => {
+		await this.ensureInit();
+		await this.createDataset(datasetId, datasetOptions);
+		if (!await this.tableExists(datasetId, tableId)) await this.client.dataset(datasetId).createTable(tableId, options || {});
+	};
+	/**
+	* Check to see whether a given BigQuery table exists.
+	* https://cloud.google.com/bigquery/docs/samples/bigquery-table-exists
+	*/
+	tableExists = async (datasetId, tableId) => {
+		await this.ensureInit();
+		let response = false;
+		const tables = await this.getTables(datasetId);
+		for (let i = 0; i < tables.length; i++) if (tables[i].id === tableId) {
+			response = true;
+			break;
+		}
+		return response;
+	};
+	getTables = async (datasetId) => {
+		await this.ensureInit();
+		let response = [];
+		const tables = await this.client.dataset(datasetId).getTables();
+		if (tables?.[0]) for (let i = 0; i < tables[0].length; i++) response.push({ id: tables[0][i].id });
+		return response;
+	};
+};
+
+//#endregion
+//#region src/googleCloud/bigquery/server/googleCloudBigquery.ts
+const googleCloudBigqueryNamespaces = /* @__PURE__ */ new Map();
+const googleCloudBigqueryClient = async (key = "default", projectId, config, vaultId, itemId) => {
+	if (googleCloudBigqueryNamespaces.has(key)) return googleCloudBigqueryNamespaces.get(key);
+	let instanceConfig;
+	if (config) instanceConfig = {
+		...config,
+		projectId
+	};
+	else if (vaultId && itemId) instanceConfig = {
+		...await (await onePasswordClient()).getJsonNote(vaultId, itemId),
+		projectId
+	};
+	else if (process.env.GOOGLE_CLOUD_VAULT_ID && process.env.GOOGLE_CLOUD_ITEM_ID) instanceConfig = {
+		...await (await onePasswordClient()).getJsonNote(process.env.GOOGLE_CLOUD_VAULT_ID, process.env.GOOGLE_CLOUD_ITEM_ID),
+		projectId
+	};
+	else throw new Error(`Config required for namespace '${key}'`);
+	const namespace = new GoogleCloudBigqueryNamespace(key, instanceConfig);
+	googleCloudBigqueryNamespaces.set(key, namespace);
+	return namespace;
+};
+const getHandlerPath = (input) => {
+	return `${input.split(process.cwd())[1].substring(1).replace(/\\/g, "/")}`;
+};
+
+//#endregion
+//#region src/googleCloud/bigquery/server/loadData.ts
+/**
+* Load data into a given table using Google Cloud Storage.
+*/
+const loadData = async ({ file, googleCloudBigqueryClient, googleCloudStorageClient, table }) => {
+	if (await googleCloudBigqueryClient.tableExists(table.datasetId, table.tableId)) await googleCloudBigqueryClient.client.dataset(table.datasetId).table(table.tableId).load(googleCloudStorageClient.client.bucket(file.bucket).file(file.key), file.metadata);
+};
+
+//#endregion
+export { GoogleCloudBigqueryNamespace, getHandlerPath, googleCloudBigqueryClient, loadData };

package/dist/googleCloud/server/index.d.mts

@@ -0,0 +1,2 @@
+import { n as getConfig, t as GoogleCloudConfig } from "../../index-DmCSxHCc.mjs";
+export { GoogleCloudConfig, getConfig };

package/dist/googleCloud/server/index.mjs

@@ -0,0 +1,24 @@
+//#region src/googleCloud/server/googleCloud.ts
+/**
+* Using the response from Parameter Store and format it ready to be used with Google API.
+*/
+const getConfig = (parameter, projectId) => {
+	const privateKey = parameter["private_key"].replace(/\\n/g, "\n");
+	let response = { credentials: {
+		type: parameter["type"],
+		project_id: parameter["project_id"],
+		private_key_id: parameter["private_key_id"],
+		private_key: privateKey,
+		client_email: parameter["client_email"],
+		client_id: parameter["client_id"],
+		auth_uri: parameter["auth_uri"],
+		token_uri: parameter["token_uri"],
+		auth_provider_x509_cert_url: parameter["auth_provider_x509_cert_url"],
+		client_x509_cert_url: parameter["client_x509_cert_url"]
+	} };
+	if (projectId) response["projectId"] = projectId;
+	return response;
+};
+
+//#endregion
+export { getConfig };

package/dist/googleCloud/sheets/server/index.d.mts

@@ -0,0 +1,22 @@
+import { t as BaseNamespace } from "../../../index-DwB8X1lz.mjs";
+import { t as GoogleCloudConfig } from "../../../index-DmCSxHCc.mjs";
+import * as _googleapis_sheets0 from "@googleapis/sheets";
+import { GoogleAuth } from "googleapis-common";
+
+//#region src/googleCloud/sheets/server/GoogleCloudSheetsNamespace.d.ts
+type GetBatchDataProps = {
+  spreadsheetId: string;
+  ranges: string[];
+  dateTimeRender?: string;
+  valueRender?: string;
+};
+declare class GoogleCloudSheetsNamespace extends BaseNamespace {
+  client: GoogleAuth;
+  config: GoogleCloudConfig & {
+    projectId?: string;
+  };
+  ensureInit: () => Promise<void>;
+  getBatchData: (props: GetBatchDataProps) => Promise<_googleapis_sheets0.sheets_v4.Schema$BatchGetValuesResponse>;
+}
+//#endregion
+export { GoogleCloudSheetsNamespace };

package/dist/googleCloud/sheets/server/index.mjs

@@ -0,0 +1,31 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { getConfig } from "../../server/index.mjs";
+
+//#region src/googleCloud/sheets/server/GoogleCloudSheetsNamespace.ts
+var GoogleCloudSheetsNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const googleApisSheets = await import("@googleapis/sheets");
+			const formattedConfig = getConfig(this.config, this.config?.projectId);
+			this.client = new googleApisSheets.auth.GoogleAuth({
+				...formattedConfig,
+				scopes: ["https://www.googleapis.com/auth/spreadsheets"]
+			});
+		} catch (e) {
+			throw new Error("Google Sheets Client not installed");
+		}
+	};
+	getBatchData = async (props) => {
+		await this.ensureInit();
+		return (await (await import("@googleapis/sheets")).sheets("v4").spreadsheets.values.batchGet({
+			auth: this.client,
+			dateTimeRenderOption: props?.dateTimeRender || "FORMATTED_STRING",
+			ranges: props.ranges,
+			spreadsheetId: props.spreadsheetId,
+			valueRenderOption: props?.valueRender || "UNFORMATTED_VALUE"
+		})).data;
+	};
+};
+
+//#endregion
+export { GoogleCloudSheetsNamespace };

package/dist/googleCloud/storage/server/index.d.mts

@@ -0,0 +1,31 @@
+import { t as BaseNamespace } from "../../../index-DwB8X1lz.mjs";
+import { t as GoogleCloudConfig } from "../../../index-DmCSxHCc.mjs";
+import * as _google_cloud_storage0 from "@google-cloud/storage";
+import { Storage } from "@google-cloud/storage";
+import { GoogleAuthOptions } from "@google-cloud/common";
+
+//#region src/googleCloud/storage/server/GoogleCloudStorageNamespace.d.ts
+declare class GoogleCloudStorageNamespace extends BaseNamespace {
+  client: Storage;
+  config: GoogleCloudConfig & {
+    projectId?: string;
+  };
+  ensureInit: () => Promise<void>;
+  /**
+   * Copy a local file to Google Cloud Storage.
+   */
+  copyToCloud: (bucket: string, localFile: string, options?: {}) => Promise<_google_cloud_storage0.UploadResponse>;
+  /**
+   * Check to see if a file exists but don't get the contents.
+   */
+  fileExists: (bucket: string, key: string) => Promise<boolean>;
+  /**
+   * Write a file to Google Cloud Storage.
+   */
+  writeFile: (bucket: string, key: string, data: any, options?: {}) => Promise<unknown>;
+}
+//#endregion
+//#region src/googleCloud/storage/server/googleCloudStorage.d.ts
+declare const googleCloudStorageClient: (key?: string, projectId?: string, config?: GoogleAuthOptions, vaultId?: string, itemId?: string) => Promise<GoogleCloudStorageNamespace>;
+//#endregion
+export { GoogleCloudStorageNamespace, googleCloudStorageClient };

package/dist/googleCloud/storage/server/index.mjs

@@ -0,0 +1,79 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { onePasswordClient } from "../../../onePassword/server/index.mjs";
+import { getConfig } from "../../server/index.mjs";
+
+//#region src/googleCloud/storage/server/GoogleCloudStorageNamespace.ts
+var GoogleCloudStorageNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { Storage } = await import("@google-cloud/storage");
+			this.client = new Storage(getConfig(this.config, this.config?.projectId));
+		} catch (e) {
+			throw new Error("Google Cloud Storage Client not installed");
+		}
+	};
+	/**
+	* Copy a local file to Google Cloud Storage.
+	*/
+	copyToCloud = async (bucket, localFile, options = {}) => {
+		await this.ensureInit();
+		return await this.client.bucket(bucket).upload(localFile, options);
+	};
+	/**
+	* Check to see if a file exists but don't get the contents.
+	*/
+	fileExists = async (bucket, key) => {
+		await this.ensureInit();
+		return (await this.client.bucket(bucket).file(key).exists())?.[0];
+	};
+	/**
+	* Write a file to Google Cloud Storage.
+	*/
+	writeFile = async (bucket, key, data, options = {}) => {
+		await this.ensureInit();
+		const dataStream = new (await (import("stream"))).PassThrough();
+		const googleFile = this.client.bucket(bucket).file(key);
+		dataStream.push(data);
+		dataStream.push(null);
+		return await new Promise((resolve, reject) => {
+			dataStream.pipe(googleFile.createWriteStream({
+				contentType: "auto",
+				resumable: false,
+				validation: false,
+				metadata: {},
+				...options
+			})).on("error", (error) => {
+				reject(error);
+			}).on("finish", () => {
+				resolve(true);
+			});
+		});
+	};
+};
+
+//#endregion
+//#region src/googleCloud/storage/server/googleCloudStorage.ts
+const googleCloudStorageNamespaces = /* @__PURE__ */ new Map();
+const googleCloudStorageClient = async (key = "default", projectId, config, vaultId, itemId) => {
+	if (googleCloudStorageNamespaces.has(key)) return googleCloudStorageNamespaces.get(key);
+	let instanceConfig;
+	if (config) instanceConfig = {
+		...config,
+		projectId
+	};
+	else if (vaultId && itemId) instanceConfig = {
+		...await (await onePasswordClient()).getJsonNote(vaultId, itemId),
+		projectId
+	};
+	else if (process.env.GOOGLE_CLOUD_VAULT_ID && process.env.GOOGLE_CLOUD_ITEM_ID) instanceConfig = {
+		...await (await onePasswordClient()).getJsonNote(process.env.GOOGLE_CLOUD_VAULT_ID, process.env.GOOGLE_CLOUD_ITEM_ID),
+		projectId
+	};
+	else throw new Error(`Config required for namespace '${key}'`);
+	const namespace = new GoogleCloudStorageNamespace(key, instanceConfig);
+	googleCloudStorageNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { GoogleCloudStorageNamespace, googleCloudStorageClient };

package/dist/googlePageSpeed/server/index.d.mts

@@ -0,0 +1,34 @@
+import { t as BaseNamespace } from "../../index-DwB8X1lz.mjs";
+
+//#region src/googlePageSpeed/server/GooglePageSpeedNamespace.d.ts
+/**
+ * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+ */
+declare class GooglePageSpeedNamespace extends BaseNamespace {
+  client: boolean;
+  config: GooglePageSpeedConfig;
+  ensureInit: () => Promise<void>;
+  getReport: (url: string, inputCategory?: Category, inputStrategy?: Strategy) => Promise<any>;
+}
+//#endregion
+//#region src/googlePageSpeed/server/googlePageSpeed.d.ts
+type GooglePageSpeedConfig = {
+  apiKey: string;
+};
+declare const googlePageSpeedClient: (key?: string, config?: GooglePageSpeedConfig, vaultId?: string, itemId?: string) => Promise<GooglePageSpeedNamespace>;
+declare const category: {
+  readonly CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED";
+  readonly ACCESSIBILITY: "ACCESSIBILITY";
+  readonly BEST_PRACTICES: "BEST_PRACTICES";
+  readonly PERFORMANCE: "PERFORMANCE";
+  readonly SEO: "SEO";
+};
+type Category = typeof category[keyof typeof category];
+declare const strategy: {
+  readonly STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED";
+  readonly DESKTOP: "DESKTOP";
+  readonly MOBILE: "MOBILE";
+};
+type Strategy = typeof strategy[keyof typeof strategy];
+//#endregion
+export { Category, GooglePageSpeedConfig, GooglePageSpeedNamespace, Strategy, category, googlePageSpeedClient, strategy };