@8ms/helpers 2.3.26 → 2.3.28

package/dist/index-DW9yJLtI.d.mts

@@ -0,0 +1,67 @@
+import { z } from "zod/v4";
+
+//#region src/api/ApiResponseClass.d.ts
+type ConstructorProps = {
+  body?: any;
+  error?: any;
+  state?: ApiState;
+};
+/**
+ * Class version of the API to enable quicker instances.
+ */
+declare class ApiResponseClass<T = any, E = any> {
+  state: ApiState;
+  body: T | null;
+  error: E | null;
+  constructor({
+    body,
+    error,
+    state
+  }?: ConstructorProps);
+  fromJson: (input: ApiResponse) => this;
+  getBody: () => any;
+  getBodyDefaultTo: (keys: any | any[], defaultValue: any) => any;
+  getError: () => any;
+  getJson: () => ApiResponse<T, E>;
+  getApiState: () => ApiState;
+  isError: () => boolean;
+  isIdle: () => boolean;
+  isPending: () => boolean;
+  isSuccess: () => boolean;
+  setToIdle: () => this;
+  setToPending: () => this;
+  setToError: (error: any, body?: any) => this;
+  setToSuccess: (body: any) => this;
+  setBody: (body: any) => this;
+  setError: (error: any) => this;
+  setApiState: (state: ApiState) => this;
+  validateZod: <T_1>(schema: z.ZodSchema<T_1>) => ApiResponseClass<T_1, E>;
+}
+//#endregion
+//#region src/api/api.d.ts
+declare const apiState: {
+  readonly CANCELLED: "CANCELLED";
+  readonly ERROR: "ERROR";
+  readonly IDLE: "IDLE";
+  readonly PENDING: "PENDING";
+  readonly SUCCESS: "SUCCESS";
+  readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+};
+type ApiState = typeof apiState[keyof typeof apiState];
+type ApiResponse<T = any, E = any> = {
+  body: T | null;
+  error: E | null;
+  state: ApiState;
+};
+declare const defaultResponse: ApiResponse;
+declare const unexpectedError: string;
+//#endregion
+//#region src/api/functions.d.ts
+declare const isCancelled: (apiResponse: ApiResponse) => boolean;
+declare const isError: (apiResponse: ApiResponse) => boolean;
+declare const isIdle: (apiResponse: ApiResponse) => boolean;
+declare const isPending: (apiResponse: ApiResponse) => boolean;
+declare const isSuccess: (apiResponse: ApiResponse) => boolean;
+declare const isValidationError: (apiResponse: ApiResponse) => boolean;
+//#endregion
+export { isSuccess as a, ApiState as c, unexpectedError as d, ApiResponseClass as f, isPending as i, apiState as l, isError as n, isValidationError as o, isIdle as r, ApiResponse as s, isCancelled as t, defaultResponse as u };

package/dist/index-DmCSxHCc.d.mts

@@ -0,0 +1,32 @@
+//#region src/googleCloud/server/googleCloud.d.ts
+type GoogleCloudConfig = {
+  type: string;
+  project_id: string;
+  private_key_id: string;
+  private_key: string;
+  client_email: string;
+  client_id: string;
+  auth_uri: string;
+  token_uri: string;
+  auth_provider_x509_cert_url: string;
+  client_x509_cert_url: string;
+};
+/**
+ * Using the response from Parameter Store and format it ready to be used with Google API.
+ */
+declare const getConfig: (parameter: GoogleCloudConfig, projectId?: string) => {
+  credentials: {
+    type: string;
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+  };
+};
+//#endregion
+export { getConfig as n, GoogleCloudConfig as t };

package/dist/index-DwB8X1lz.d.mts

@@ -0,0 +1,32 @@
+//#region src/_class/BaseClass.d.ts
+declare class BaseClass {
+  /**
+   * Shortcut to set a value to an array and return the instance.
+   */
+  protected _setArray: (fields: any | any[], input: any | any[]) => this;
+  /**
+   * Shortcut to set a value and return the instance.
+   */
+  protected _setValue: (fields: any | any[], input: any) => this;
+  /**
+   * Shortcut to add a value to an existing array.
+   */
+  protected _push: (fields: any | any[], input: any | any[]) => this;
+  /**
+   * Shortcut to get a value, but default if the fields don't exist.
+   */
+  protected _get: (fields: any | any[], defaultValue?: any) => any;
+}
+//#endregion
+//#region src/_class/BaseNamespace.d.ts
+declare class BaseNamespace {
+  client: any;
+  key: string;
+  config: any;
+  constructor(key: string, config: any);
+  ensureInit: () => Promise<void>;
+  reset: () => void;
+  getClient: () => Promise<any>;
+}
+//#endregion
+export { BaseClass as n, BaseNamespace as t };

package/dist/inngest/index.d.mts

@@ -0,0 +1,10 @@
+//#region src/inngest/inngest.d.ts
+declare const inngestState: {
+  RUNNING: string;
+  COMPLETED: string;
+  FAILED: string;
+  CANCELLED: string;
+};
+type InngestState = typeof inngestState[keyof typeof inngestState];
+//#endregion
+export { InngestState, inngestState };

package/dist/inngest/index.mjs

@@ -0,0 +1,10 @@
+//#region src/inngest/inngest.ts
+const inngestState = {
+	RUNNING: "Running",
+	COMPLETED: "Completed",
+	FAILED: "Failed",
+	CANCELLED: "Cancelled"
+};
+
+//#endregion
+export { inngestState };

package/dist/json/index.d.mts

@@ -0,0 +1,7 @@
+//#region src/json/getJsonNewline.d.ts
+declare const getJsonNewline: (data: any) => string;
+//#endregion
+//#region src/json/isJson.d.ts
+declare const isJson: (input: any) => boolean;
+//#endregion
+export { getJsonNewline, isJson };

package/dist/json/index.mjs

@@ -0,0 +1,27 @@
+import { getArray } from "../array/index.mjs";
+
+//#region src/json/getJsonNewline.ts
+const getJsonNewline = (data) => {
+	return getArray(data).map((row) => JSON.stringify(row)).join("\n");
+};
+
+//#endregion
+//#region src/json/isJson.ts
+const isJson = (input) => {
+	if (typeof input !== "string") try {
+		const stringified = JSON.stringify(input);
+		JSON.parse(stringified);
+		return true;
+	} catch (e) {
+		return false;
+	}
+	try {
+		JSON.parse(input);
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
+
+//#endregion
+export { getJsonNewline, isJson };

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

@@ -0,0 +1,56 @@
+import { t as BaseNamespace } from "../../index-DwB8X1lz.mjs";
+
+//#region src/littleWarden/server/LittleWardenNamespace.d.ts
+/**
+ * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+ */
+declare class LittleWardenNamespace extends BaseNamespace {
+  client: boolean;
+  config: LittleWardenConfig;
+  ensureInit: () => Promise<void>;
+  getReport: (urlId: string) => Promise<any>;
+}
+//#endregion
+//#region src/littleWarden/server/getUrlStatus.d.ts
+/**
+ * Get the URL Status for a given URL ID from Little Warden.
+ */
+declare const getUrlStatus: (apiKey: string, urlId: string) => Promise<any>;
+//#endregion
+//#region src/littleWarden/server/littleWarden.d.ts
+type LittleWardenConfig = {
+  apiKey: string;
+};
+declare const littleWardenClient: (key?: string, config?: LittleWardenConfig, vaultId?: string, itemId?: string) => Promise<LittleWardenNamespace>;
+declare const littleWardenState: {
+  readonly ALL_GOOD: "all_good";
+  readonly DANGER: "danger";
+  readonly WARNING: "warning";
+};
+type LittleWardenState = typeof littleWardenState[keyof typeof littleWardenState];
+/**
+ * Check if the field is All Good.
+ */
+declare const isAllGood: ({
+  field
+}: {
+  field: any;
+}) => boolean;
+/**
+ * Check if the field is Warning.
+ */
+declare const isWarning: ({
+  field
+}: {
+  field: any;
+}) => boolean;
+/**
+ * Check if the field is Danger.
+ */
+declare const isDanger: ({
+  field
+}: {
+  field: any;
+}) => boolean;
+//#endregion
+export { LittleWardenConfig, LittleWardenNamespace, LittleWardenState, getUrlStatus, isAllGood, isDanger, isWarning, littleWardenClient, littleWardenState };

package/dist/littleWarden/server/index.mjs

@@ -0,0 +1,79 @@
+import { BaseNamespace } from "../../_class/index.mjs";
+import "../../api-DGKJDAfb.mjs";
+import { get } from "../../axios/index.mjs";
+import { onePasswordClient } from "../../onePassword/server/index.mjs";
+
+//#region src/littleWarden/server/LittleWardenNamespace.ts
+/**
+* Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+*/
+var LittleWardenNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			this.client = true;
+		} catch (e) {
+			throw new Error("Google PageSpeed Client not installed");
+		}
+	};
+	getReport = async (urlId) => {
+		const apiResponse = await get(`https://littlewarden.com/api/sites/${urlId}`, { headers: { "Authorization": `Token token="${this.config.apiKey}"` } });
+		if (apiResponse.isSuccess()) return apiResponse.getBody();
+		return null;
+	};
+};
+
+//#endregion
+//#region src/littleWarden/server/getUrlStatus.ts
+/**
+* Get the URL Status for a given URL ID from Little Warden.
+*/
+const getUrlStatus = async (apiKey, urlId) => {
+	return (await get(`https://littlewarden.com/api/sites/${urlId}`, { headers: { "Authorization": `Token token="${apiKey}"` } })).getBodyDefaultTo(["data", "site"], {});
+};
+
+//#endregion
+//#region src/littleWarden/server/littleWarden.ts
+const littleWardenNamespaces = /* @__PURE__ */ new Map();
+const littleWardenClient = async (key = "default", config, vaultId, itemId) => {
+	if (littleWardenNamespaces.has(key)) return littleWardenNamespaces.get(key);
+	let instanceConfig;
+	if (config) instanceConfig = config;
+	else if (vaultId && itemId) instanceConfig = await (await onePasswordClient()).getJsonNote(vaultId, itemId);
+	else if (process.env.LITTLE_WARDEN_VAULT_ID && process.env.LITTLE_WARDEN_ITEM_ID) instanceConfig = await (await onePasswordClient()).getJsonNote(process.env.LITTLE_WARDEN_VAULT_ID, process.env.LITTLE_WARDEN_ITEM_ID);
+	else throw new Error(`Config required for namespace '${key}'`);
+	const namespace = new LittleWardenNamespace(key, instanceConfig);
+	littleWardenNamespaces.set(key, namespace);
+	return namespace;
+};
+const littleWardenState = {
+	ALL_GOOD: "all_good",
+	DANGER: "danger",
+	WARNING: "warning"
+};
+/**
+* Check if the field is All Good.
+*/
+const isAllGood = ({ field }) => {
+	let response = false;
+	if (void 0 !== field && void 0 !== field["status"]) response = littleWardenState.ALL_GOOD === field["status"];
+	return response;
+};
+/**
+* Check if the field is Warning.
+*/
+const isWarning = ({ field }) => {
+	let response = false;
+	if (void 0 !== field && void 0 !== field["status"]) response = littleWardenState.WARNING === field["status"];
+	return response;
+};
+/**
+* Check if the field is Danger.
+*/
+const isDanger = ({ field }) => {
+	let response = false;
+	if (void 0 !== field && void 0 !== field["status"]) response = littleWardenState.DANGER === field["status"];
+	return response;
+};
+
+//#endregion
+export { LittleWardenNamespace, getUrlStatus, isAllGood, isDanger, isWarning, littleWardenClient, littleWardenState };

package/dist/lodash/index.d.mts

@@ -0,0 +1,45 @@
+//#region src/lodash/chunk.d.ts
+declare const chunk: <T>(array: T[], size: number) => T[][];
+//#endregion
+//#region src/lodash/flatten.d.ts
+declare const flatten: <T>(array: T[][]) => T[];
+//#endregion
+//#region src/lodash/set.d.ts
+declare const set: <T extends object>(obj: T, path: string | string[], value: unknown) => T;
+//#endregion
+//#region src/lodash/trim.d.ts
+declare const trim: (str: string, chars?: string) => string;
+//#endregion
+//#region src/lodash/isDate.d.ts
+declare const isDate: (value: unknown) => value is Date;
+//#endregion
+//#region src/lodash/isEmpty.d.ts
+declare const isEmpty: (value: unknown) => boolean;
+//#endregion
+//#region src/lodash/isEqual.d.ts
+declare const isEqual: (a: unknown, b: unknown) => boolean;
+//#endregion
+//#region src/lodash/isFunction.d.ts
+declare const isFunction: (value: any) => value is Function;
+//#endregion
+//#region src/lodash/isObject.d.ts
+declare const isObject: (value: unknown) => value is object;
+//#endregion
+//#region src/lodash/merge.d.ts
+declare const merge: <T extends object>(target: T, ...sources: any[]) => T;
+//#endregion
+//#region src/lodash/orderBy.d.ts
+type OrderDirection = "asc" | "desc";
+type Iteratee<T> = ((item: T) => unknown) | string;
+declare const orderBy: <T>(collection: T[] | Record<string, T>, iteratees: Iteratee<T> | Iteratee<T>[], orders?: OrderDirection | OrderDirection[]) => T[];
+//#endregion
+//#region src/lodash/unescape.d.ts
+declare const unescape: (str: string) => string;
+//#endregion
+//#region src/lodash/uniq.d.ts
+declare const uniq: (arr: any[]) => any[];
+//#endregion
+//#region src/lodash/uniqBy.d.ts
+declare const uniqBy: <T>(collection: T[], iteratee: ((item: T) => unknown) | string) => T[];
+//#endregion
+export { chunk, flatten, isDate, isEmpty, isEqual, isFunction, isObject, merge, orderBy, set, trim, unescape, uniq, uniqBy };

package/dist/lodash/index.mjs

@@ -0,0 +1,177 @@
+//#region src/lodash/chunk.ts
+const chunk = (array, size) => {
+	const result = [];
+	for (let i = 0; i < array.length; i += size) result.push(array.slice(i, i + size));
+	return result;
+};
+
+//#endregion
+//#region src/lodash/flatten.ts
+const flatten = (array) => [].concat(...array);
+
+//#endregion
+//#region src/lodash/set.ts
+const set = (obj, path, value) => {
+	if (obj == null) return obj;
+	const keys = Array.isArray(path) ? path : path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		const nextKey = keys[i + 1];
+		const nextIsIndex = /^\d+$/.test(nextKey);
+		if (current[key] == null || typeof current[key] !== "object") current[key] = nextIsIndex ? [] : {};
+		current = current[key];
+	}
+	current[keys[keys.length - 1]] = value;
+	return obj;
+};
+
+//#endregion
+//#region src/lodash/trim.ts
+const trim = (str, chars) => {
+	if (!chars) return str.trim();
+	const escaped = chars.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+	const pattern = new RegExp(`^[${escaped}]+|[${escaped}]+$`, "g");
+	return str.replace(pattern, "");
+};
+
+//#endregion
+//#region src/lodash/isDate.ts
+const isDate = (value) => {
+	return value instanceof Date && !isNaN(value.getTime());
+};
+
+//#endregion
+//#region src/lodash/isEmpty.ts
+const isEmpty = (value) => {
+	if (value == null) return true;
+	if (typeof value === "boolean" || typeof value === "number") return true;
+	if (typeof value === "string" || Array.isArray(value)) return value.length === 0;
+	if (value instanceof Map || value instanceof Set) return value.size === 0;
+	if (typeof value === "object") return Object.keys(value).length === 0;
+	return true;
+};
+
+//#endregion
+//#region src/lodash/isEqual.ts
+const isEqual = (a, b) => {
+	if (a === b) return true;
+	if (a == null || b == null) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (a instanceof RegExp && b instanceof RegExp) return a.toString() === b.toString();
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((item, i) => isEqual(item, b[i]));
+	}
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	if (a instanceof Map && b instanceof Map) {
+		if (a.size !== b.size) return false;
+		for (const [key, val] of a) if (!b.has(key) || !isEqual(val, b.get(key))) return false;
+		return true;
+	}
+	if (a instanceof Set && b instanceof Set) {
+		if (a.size !== b.size) return false;
+		for (const val of a) if (!b.has(val)) return false;
+		return true;
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]));
+	}
+	return false;
+};
+
+//#endregion
+//#region src/lodash/isFunction.ts
+const isFunction = (value) => typeof value === "function";
+
+//#endregion
+//#region src/lodash/isObject.ts
+const isObject = (value) => {
+	const type = typeof value;
+	return value != null && (type === "object" || type === "function");
+};
+
+//#endregion
+//#region src/lodash/merge.ts
+const merge = (target, ...sources) => {
+	for (const source of sources) {
+		if (source == null) continue;
+		for (const key of Object.keys(source)) {
+			const sourceVal = source[key];
+			const targetVal = target[key];
+			if (Array.isArray(sourceVal) && Array.isArray(targetVal)) {
+				const merged = [...targetVal];
+				for (let i = 0; i < sourceVal.length; i++) if (sourceVal[i] != null && typeof sourceVal[i] === "object") merged[i] = merge(targetVal[i] ?? {}, sourceVal[i]);
+				else merged[i] = sourceVal[i];
+				target[key] = merged;
+			} else if (sourceVal != null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && !(sourceVal instanceof Date)) target[key] = merge(targetVal != null && typeof targetVal === "object" ? targetVal : {}, sourceVal);
+			else if (sourceVal !== void 0) target[key] = sourceVal;
+		}
+	}
+	return target;
+};
+
+//#endregion
+//#region src/lodash/orderBy.ts
+const orderBy = (collection, iteratees, orders = "asc") => {
+	const arr = Array.isArray(collection) ? collection : Object.values(collection);
+	const keys = Array.isArray(iteratees) ? iteratees : [iteratees];
+	const dirs = Array.isArray(orders) ? orders : [orders];
+	const getValue = (item, key) => {
+		if (typeof key === "function") return key(item);
+		return key.split(".").reduce((acc, part) => acc?.[part], item);
+	};
+	return [...arr].sort((a, b) => {
+		for (let i = 0; i < keys.length; i++) {
+			const dir = dirs[i] === "desc" ? -1 : 1;
+			const aVal = getValue(a, keys[i]);
+			const bVal = getValue(b, keys[i]);
+			if (aVal === bVal) continue;
+			if (aVal == null) return 1;
+			if (bVal == null) return -1;
+			if (typeof aVal === "string" && typeof bVal === "string") return aVal.localeCompare(bVal) * dir;
+			return (aVal < bVal ? -1 : 1) * dir;
+		}
+		return 0;
+	});
+};
+
+//#endregion
+//#region src/lodash/unescape.ts
+const unescape = (str) => {
+	const htmlEntities = {
+		"&amp;": "&",
+		"&lt;": "<",
+		"&gt;": ">",
+		"&quot;": "\"",
+		"&#39;": "'"
+	};
+	return str.replace(/&(?:amp|lt|gt|quot|#39);/g, (match) => htmlEntities[match]);
+};
+
+//#endregion
+//#region src/lodash/uniq.ts
+const uniq = (arr) => [...new Set(arr)];
+
+//#endregion
+//#region src/lodash/uniqBy.ts
+const uniqBy = (collection, iteratee) => {
+	const seen = /* @__PURE__ */ new Set();
+	const getValue = (item) => {
+		if (typeof iteratee === "function") return iteratee(item);
+		return iteratee.split(".").reduce((acc, part) => acc?.[part], item);
+	};
+	return collection.filter((item) => {
+		const key = getValue(item);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+};
+
+//#endregion
+export { chunk, flatten, isDate, isEmpty, isEqual, isFunction, isObject, merge, orderBy, set, trim, unescape, uniq, uniqBy };

package/dist/lumar/api/server/index.d.mts

@@ -0,0 +1,66 @@
+import { f as ApiResponseClass } from "../../../index-DW9yJLtI.mjs";
+
+//#region src/lumar/api/server/lumarApi.d.ts
+type Filter = {
+  field: string;
+  operand: string;
+  value: string;
+};
+declare const operand: {
+  readonly EQUALS: "eql";
+  readonly CONTAINS: "cont";
+  readonly LESS_THAN: "lt";
+  readonly LESS_THAN_OR_EQUAL: "lte";
+  readonly GREATER_THAN: "gt";
+  readonly GREATER_THAN_OR_EQUAL: "gte";
+  readonly REGEX: "rgx";
+  readonly NOT_REGEX: "nrgx";
+};
+type Operand = typeof operand[keyof typeof operand];
+declare const order: {
+  readonly ASCENDING: "asc";
+  readonly DESCENDING: "desc";
+};
+type Order = typeof order[keyof typeof order];
+type OrderRow = {
+  direction: Order;
+  field: string;
+};
+declare const report: {
+  readonly CRAWL_STATISTICS: "crawl_statistics";
+  readonly CUSTOM: "custom";
+  readonly LIST_PROJECTS: "list_projects";
+  readonly LIST_CRAWLS: "list_crawls";
+  readonly LIST_REPORTS: "list_reports";
+  readonly REPORT_ROWS: "report_rows";
+  readonly REPORT_STATISTICS: "report_statistics";
+  readonly REPORT_SUMMARY: "report_summary";
+};
+type Report = typeof report[keyof typeof report];
+//#endregion
+//#region src/lumar/api/server/buildRequest.d.ts
+type BuildRequestProps = {
+  crawlId?: number;
+  customPath?: string;
+  filters?: Filter[];
+  limit?: number;
+  orders?: OrderRow[];
+  page?: number;
+  projectId?: number;
+  report?: Report;
+  subReport?: string;
+};
+declare const buildRequest: (props: BuildRequestProps) => string;
+//#endregion
+//#region src/lumar/api/server/getData.d.ts
+declare const getData: (url: string, accessToken: string) => Promise<ApiResponseClass<any, any>>;
+//#endregion
+//#region src/lumar/api/server/initClient.d.ts
+/**
+ * http://api-docs.deepcrawl.com/
+ * Renew the Lumar user token.
+ * Token lasts for 6 hours.
+ */
+declare const initClient: (apiId: string, apiKey: string) => Promise<any>;
+//#endregion
+export { BuildRequestProps, Filter, Operand, Order, OrderRow, Report, buildRequest, getData, initClient, operand, order, report };