@liase/core 1.0.0

package/dist/lib/zod.js

@@ -0,0 +1,290 @@
+import util from "node:util";
+import chalk from "chalk";
+import pluralize from "pluralize";
+import { capitaliseType, formatObjectPath } from "./utils.js";
+function isZodError(error) {
+    return error?.constructor?.name === "ZodError";
+}
+export function zodParseOrThrow(zodSchema, 
+// biome-ignore lint/suspicious/noExplicitAny: zod schema accepts any input for runtime validation
+input, options = {}) {
+    try {
+        return zodSchema.parse(input);
+    }
+    catch (error) {
+        // We might be passing a zodSchema from a plugin with a different instance of the Zod library
+        // and thus if that gives an error it might not be an instance of the ZodError from the exact Zod library
+        // we're using. Thus we match using the constructor name to be safe.
+        if (isZodError(error)) {
+            const friendlyError = new FriendlyZodError(error, {
+                message: options.errorMessage,
+                inputData: input,
+                context: options.context,
+            });
+            throw friendlyError;
+        }
+        throw error;
+    }
+}
+export const getType = (value) => {
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    return typeof value;
+};
+function getPathInfo(inputData, path) {
+    // biome-ignore lint/suspicious/noExplicitAny: complex accumulator type in path traversal
+    return path.reduce(
+    // biome-ignore lint/suspicious/noExplicitAny: complex accumulator type in path traversal
+    (accumulator, currentArrayValue) => {
+        const exists = typeof accumulator.value !== "undefined" &&
+            currentArrayValue in accumulator.value;
+        const value = accumulator.value?.[currentArrayValue];
+        const type = getType(value);
+        return {
+            exists,
+            value,
+            type,
+            longestExistingPath: exists
+                ? [...accumulator.longestExistingPath, currentArrayValue]
+                : accumulator.longestExistingPath,
+            typeAtLongestExistingPath: exists
+                ? type
+                : accumulator.typeAtLongestExistingPath,
+        };
+    }, {
+        exists: true,
+        value: inputData,
+        longestExistingPath: [],
+        typeAtLongestExistingPath: getType(inputData),
+    });
+}
+export class FriendlyZodError extends Error {
+    #inputData;
+    zodError;
+    context;
+    constructor(error, { message, inputData, context } = {}) {
+        super(message ?? error?.message ?? "Error when validating data");
+        // Use class name as the name of the error
+        this.name = this.constructor.name;
+        this.zodError = error;
+        this.stack = error.stack;
+        this.context = context;
+        this.#inputData = inputData;
+        this.message = this.formattedErrorInfo;
+        // Explicitly set the prototype to maintain the correct prototype chain is
+        // required for "instanceOf" to work as expected
+        Object.setPrototypeOf(this, FriendlyZodError.prototype);
+    }
+    formatZodIssue(issue, includePath = true) {
+        const { path, ...detailWithoutPath } = issue;
+        const formattedPath = formatObjectPath(path);
+        let pathInfo = getPathInfo(this.#inputData, path);
+        let issueMessage;
+        if (issue.code === "invalid_type") {
+            if (pathInfo.exists) {
+                const includeValue = ["string", "number"].includes(pathInfo.type);
+                issueMessage = `Expected ${includePath ? `${formattedPath} to be an` : ""}${issue.expected} but ${includeValue
+                    ? `the received value ${JSON.stringify(pathInfo.value)} was`
+                    : "received"} a ${issue.received}.`;
+            }
+            else {
+                const keyOrIndex = path.at(-1);
+                const parentPath = formatObjectPath(path.slice(0, -1));
+                const isIndex = pathInfo.typeAtLongestExistingPath === "array" &&
+                    typeof keyOrIndex === "number";
+                issueMessage =
+                    `Missing ${isIndex ? "element" : "key"} "${keyOrIndex}" at ${parentPath},` +
+                        ` expected to receive a ${issue.expected}.`;
+            }
+        }
+        else if (issue.code === "unrecognized_keys") {
+            const keys = issue.keys.map((key) => {
+                pathInfo = getPathInfo(this.#inputData, [...path, key]);
+                const includeValue = ["string", "number"].includes(pathInfo.type);
+                const formattedValue = includeValue
+                    ? JSON.stringify(pathInfo.value)
+                    : `is a ${pathInfo.type}`;
+                return `"${key}" (value ${formattedValue})`;
+            });
+            issueMessage = `Unexpected ${pluralize("key", keys.length)} found${includePath ? ` at ${formattedPath}` : ""}: ${keys.join(", ")}`;
+        }
+        else if (issue.code === "invalid_string") {
+            issueMessage = `${includePath ? `${formattedPath} failed` : "Failed"} ${issue.validation} validation, received ${JSON.stringify(pathInfo.value)}`;
+        }
+        else if (issue.code === "too_small" || issue.code === "too_big") {
+            let condition = "";
+            let threshold = 0;
+            if (issue.code === "too_small") {
+                threshold = issue.minimum;
+                if (issue.exact) {
+                    condition = "";
+                }
+                else if (issue.inclusive) {
+                    condition = "a minimum of";
+                }
+                else {
+                    condition = "more than";
+                }
+            }
+            else if (issue.code === "too_big") {
+                threshold = issue.maximum;
+                if (issue.exact) {
+                    condition = "";
+                }
+                else if (issue.inclusive) {
+                    condition = "a maximum of";
+                }
+                else {
+                    condition = "less than";
+                }
+            }
+            if (issue.type === "number" ||
+                issue.type === "bigint" ||
+                issue.type === "date") {
+                const capitalisedType = capitaliseType(issue.type);
+                issueMessage =
+                    `${capitalisedType} ${includePath ? `at ${formattedPath} ` : ""}must be ${condition}` +
+                        ` ${threshold} but was ${pathInfo.value}.`;
+            }
+            else {
+                const nameForTypeElement = {
+                    string: "character",
+                    array: "element",
+                    set: "element",
+                }[issue.type];
+                const capitalisedType = capitaliseType(issue.type);
+                const length = pathInfo.value.length;
+                issueMessage =
+                    `${capitalisedType} ${includePath ? ` at ${formattedPath} ` : ""}must have ${condition}` +
+                        ` ${threshold} ${nameForTypeElement}(s) but the received ${issue.type} had ${length}.`;
+            }
+        }
+        else if (issue.code === "invalid_date") {
+            issueMessage = `Expected date ${includePath ? `at ${formattedPath} ` : ""}but received value ${JSON.stringify(pathInfo.value)} is not a valid date.`;
+        }
+        else {
+            pathInfo = getPathInfo(this.#inputData, path);
+            issueMessage = `Issue with${includePath ? ` ${formattedPath}` : ""}: ${JSON.stringify(detailWithoutPath)} - ${JSON.stringify(pathInfo.value)}`;
+        }
+        return `${issueMessage}`;
+    }
+    formatZodErrorIssues(error = this.zodError, depth = 0, includePath = true) {
+        const indentSize = 2;
+        const formattedIssues = [];
+        for (const issue of error.issues) {
+            if (issue.code === "invalid_union") {
+                formattedIssues.push({
+                    formattedMessage: `${" ".repeat(depth * indentSize)}Invalid union:`,
+                    zodIssue: issue,
+                    depth,
+                });
+                for (const error of issue.unionErrors) {
+                    formattedIssues.push(...this.formatZodErrorIssues(error, depth + 1, includePath));
+                }
+            }
+            else if (issue.code === "invalid_arguments") {
+                formattedIssues.push({
+                    formattedMessage: `${" ".repeat(depth * indentSize)}Invalid arguments:`,
+                    zodIssue: issue,
+                    depth,
+                });
+                formattedIssues.push(...this.formatZodErrorIssues(issue.argumentsError, depth + 1, includePath));
+            }
+            else if (issue.code === "invalid_return_type") {
+                formattedIssues.push({
+                    formattedMessage: `${" ".repeat(depth * indentSize)}Invalid return type:`,
+                    zodIssue: issue,
+                    depth,
+                });
+                formattedIssues.push(...this.formatZodErrorIssues(issue.returnTypeError, depth + 1, includePath));
+            }
+            else {
+                formattedIssues.push({
+                    formattedMessage: " ".repeat(depth * indentSize) +
+                        this.formatZodIssue(issue, includePath),
+                    zodIssue: issue,
+                    depth,
+                });
+            }
+        }
+        return formattedIssues;
+    }
+    formatZodErrorIssuesAsDotPoints(error = this.zodError, depth = 0, indentSize = 2) {
+        return this.formatZodErrorIssues(error)
+            .map((friendlyZodIssue) => `${" ".repeat((depth + friendlyZodIssue.depth) * indentSize)}- ${friendlyZodIssue.formattedMessage}`)
+            .join("\n");
+    }
+    formatZodErrorIssuesAsTree(error = this.zodError) {
+        const issuesTree = {
+            issues: [],
+            children: {},
+        };
+        for (const friendlyZodIssue of this.formatZodErrorIssues(error, 0, false)) {
+            let issueSubtree = issuesTree;
+            const path = friendlyZodIssue.zodIssue.path.reduce((segments, segment) => {
+                if (typeof segment === "number") {
+                    const formattedSegment = `[${segment}]`;
+                    if (segments.length) {
+                        segments[segments.length - 1] += formattedSegment;
+                    }
+                    else {
+                        segments.push(formattedSegment);
+                    }
+                }
+                else {
+                    segments.push(segment);
+                }
+                return segments;
+            }, []);
+            for (const pathSegment of path) {
+                if (!(pathSegment in issueSubtree.children)) {
+                    issueSubtree.children[pathSegment] = {
+                        issues: [],
+                        children: {},
+                    };
+                }
+                issueSubtree = issueSubtree.children[pathSegment];
+            }
+            issueSubtree.issues.push(friendlyZodIssue);
+        }
+        return issuesTree;
+    }
+    formatZodErrorIssuesAsTreeString(error = this.zodError, depth = 0, indentSize = 2) {
+        function formatSubtree(issuesTree, depth) {
+            const lines = [];
+            const baseIndentation = " ".repeat(depth * indentSize);
+            for (const friendlyZodIssue of issuesTree.issues) {
+                const indentation = baseIndentation + " ".repeat(friendlyZodIssue.depth * indentSize);
+                lines.push(`${indentation}- ${friendlyZodIssue.formattedMessage.replace(/^\s+/, "")}`);
+            }
+            for (const [index, key] of Object.keys(issuesTree.children).entries()) {
+                const issuesSubtree = issuesTree.children[key];
+                if (index) {
+                    lines.push("");
+                }
+                lines.push(baseIndentation + chalk.bold(key));
+                const subtreeLines = formatSubtree(issuesSubtree, depth + 1);
+                if (subtreeLines.length) {
+                    lines.push(formatSubtree(issuesSubtree, depth + 1));
+                }
+            }
+            return lines.join("\n");
+        }
+        const issuesTree = this.formatZodErrorIssuesAsTree(error);
+        return formatSubtree(issuesTree, depth);
+    }
+    get formattedErrorInfo() {
+        return [
+            this.message,
+            ...(this.#inputData
+                ? [
+                    `Input data: \n${util.inspect(this.#inputData, { depth: null, colors: true })}`,
+                ]
+                : []),
+            "",
+            `The following ${this.zodError.issues.length > 1 ? "issues were" : "issue was"} found:`,
+            this.formatZodErrorIssuesAsTreeString(this.zodError, 1),
+        ].join("\n");
+    }
+}

package/dist/loadUrl.d.ts

@@ -0,0 +1,45 @@
+import { type OptionsInit as GotOptionsInit } from "got-scraping";
+import { type DomSelection } from "./DomSelection.js";
+type LoadUrlOptionsPlaywright = {
+    agent: "playwright";
+    responseType?: "dom";
+    headers?: Record<string, string>;
+};
+type LoadUrlOptionsGot = {
+    agent?: "got";
+    responseType?: "dom" | "text" | "json";
+    headers?: Record<string, string>;
+    body?: string;
+    retryAdditional?: GotOptionsInit["retry"];
+} & Omit<GotOptionsInit, "responseType" | "headers" | "body" | "retry" | "hooks" | "resolveBodyOnly" | "isStream" | "url" | "json" | "form">;
+export type LoadUrlOptions = LoadUrlOptionsPlaywright | LoadUrlOptionsGot;
+type LoadURLSharedResponse = {
+    statusCode: number;
+    headers: Record<string, string>;
+    cached: boolean;
+    cachedOn: Date | null;
+    request: {
+        headers: Record<string, string>;
+    };
+};
+type LoadUrlResponseDom = LoadURLSharedResponse & {
+    root: DomSelection;
+};
+type LoadUrlResponseJson = LoadURLSharedResponse & {
+    data: unknown;
+};
+type LoadUrlResponseText = LoadURLSharedResponse & {
+    data: string;
+};
+export type LoadUrlResponse = LoadUrlResponseDom | LoadUrlResponseJson | LoadUrlResponseText;
+export declare function loadUrl(url: string, options: LoadUrlOptions & {
+    responseType: "json";
+}): Promise<LoadUrlResponseJson>;
+export declare function loadUrl(url: string, options?: LoadUrlOptions & {
+    responseType?: "dom";
+}): Promise<LoadUrlResponseDom>;
+export declare function loadUrl(url: string, options: LoadUrlOptions & {
+    responseType: "text";
+}): Promise<LoadUrlResponseText>;
+export {};
+//# sourceMappingURL=loadUrl.d.ts.map

package/dist/loadUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadUrl.d.ts","sourceRoot":"","sources":["../src/loadUrl.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,IAAI,cAAc,EAEnC,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAO3E,KAAK,wBAAwB,GAAG;IAC9B,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,YAAY,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CAC3C,GAAG,IAAI,CACN,cAAc,EACZ,cAAc,GACd,SAAS,GACT,MAAM,GACN,OAAO,GACP,OAAO,GACP,iBAAiB,GACjB,UAAU,GACV,KAAK,GACL,MAAM,GACN,MAAM,CACT,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,wBAAwB,GAAG,iBAAiB,CAAC;AAE1E,KAAK,qBAAqB,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,CAAC;CACH,CAAC;AAEF,KAAK,kBAAkB,GAAG,qBAAqB,GAAG;IAChD,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AACF,KAAK,mBAAmB,GAAG,qBAAqB,GAAG;IACjD,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AACF,KAAK,mBAAmB,GAAG,qBAAqB,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB,kBAAkB,GAClB,mBAAmB,GACnB,mBAAmB,CAAC;AACxB,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,cAAc,GAAG;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GACjD,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,cAAc,GAAG;IAAE,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,GAClD,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAC/B,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,cAAc,GAAG;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GACjD,OAAO,CAAC,mBAAmB,CAAC,CAAC"}

package/dist/loadUrl.js

@@ -0,0 +1,111 @@
+import * as cheerio from "cheerio";
+import deepmerge from "deepmerge";
+import { Options as GotOptions, gotScraping, } from "got-scraping";
+import { CheerioDomSelection } from "./DomSelection.js";
+import { headersToNormalisedBasicObject } from "./lib/fetch.js";
+import { cacheResponse, getCachedResponse, } from "./lib/networkRequestsCache.js";
+export async function loadUrl(url, options) {
+    if (!options) {
+        // biome-ignore lint/style/noParameterAssign: assigning default value to optional parameter
+        options = {};
+    }
+    if (this.cacheNetworkRequests === "auto") {
+        throw Error(`The "auto" value for the cacheNetworkRequests option is not yet supported. Sorry!`);
+    }
+    if (!options.agent) {
+        options.agent = "got";
+    }
+    if (options.agent === "got") {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars -- we define only to exclude from requestOptions
+        const { agent, retryAdditional, responseType, ...requestOptions } = options;
+        const defaultGotOptions = new GotOptions();
+        let retry = defaultGotOptions.retry;
+        if (options.retryAdditional) {
+            retry = deepmerge(retry, options.retryAdditional);
+        }
+        let cache;
+        let res;
+        const cacheableRequest = {
+            url,
+            method: requestOptions.method ?? "",
+            headers: requestOptions.headers ?? {},
+            body: requestOptions.body ?? "",
+            headerGeneratorOptions: requestOptions.headerGeneratorOptions,
+        };
+        if (this.cacheNetworkRequests === "always") {
+            res = await getCachedResponse(cacheableRequest);
+        }
+        else {
+            this.cacheNetworkRequests;
+        }
+        if (!res) {
+            let sentHeaders = {};
+            const gotRes = await gotScraping({
+                url,
+                ...requestOptions,
+                responseType: "text",
+                retry,
+                cache,
+                http2: false, // Seems to be necessary otherwise got will throw "Unknown HTTP2 promise event: destroy"
+                // when caching.
+                hooks: {
+                    beforeRequest: [
+                        (options) => {
+                            sentHeaders = headersToNormalisedBasicObject(options.headers);
+                        },
+                    ],
+                },
+            });
+            if (!gotRes.ok) {
+                throw Error(`Got response status ${gotRes.statusCode} (retry count: ${gotRes.retryCount}) with body: ${gotRes.body}`);
+            }
+            res = {
+                body: gotRes.body,
+                statusCode: gotRes.statusCode,
+                headers: headersToNormalisedBasicObject(gotRes.headers),
+                request: {
+                    headers: sentHeaders ?? {},
+                },
+            };
+            await cacheResponse(cacheableRequest, res);
+        }
+        const { body, statusCode, headers, cachedOn } = res;
+        if (options.responseType === "dom" || !options.responseType) {
+            return {
+                root: new CheerioDomSelection(cheerio.load(body)),
+                statusCode,
+                headers,
+                cached: Boolean(cachedOn),
+                cachedOn: cachedOn ?? null,
+                request: res.request,
+            };
+        }
+        if (options.responseType === "json") {
+            return {
+                data: JSON.parse(body),
+                statusCode,
+                headers,
+                cached: Boolean(cachedOn),
+                cachedOn: cachedOn ?? null,
+                request: res.request,
+            };
+        }
+        if (options.responseType === "text") {
+            return {
+                data: body,
+                statusCode,
+                headers,
+                cached: Boolean(cachedOn),
+                cachedOn: cachedOn ?? null,
+                request: res.request,
+            };
+        }
+        options.responseType;
+        throw Error(`Unknown response type "${options.responseType}"`);
+    }
+    if (options.agent === "playwright") {
+        throw Error("Playwright not supported yet");
+    }
+    options.agent;
+    throw Error(`Unknown agent "${options.agent}"`);
+}

package/dist/plugins/built-in-sources/bluesky/client.d.ts

@@ -0,0 +1,11 @@
+import type { ActionContext } from "../../../ActionContext.js";
+import { AtpAgent } from "@atproto/api";
+type Props = {
+    $: ActionContext;
+    handle?: string;
+    password?: string;
+    serviceUrl?: string;
+};
+export declare const getAgent: (props: Props) => Promise<AtpAgent>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/plugins/built-in-sources/bluesky/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/plugins/built-in-sources/bluesky/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,KAAK,KAAK,GAAG;IACX,CAAC,EAAE,aAAa,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAU,OAAO,KAAK,KAAG,OAAO,CAAC,QAAQ,CAiB7D,CAAC"}

package/dist/plugins/built-in-sources/bluesky/client.js

@@ -0,0 +1,17 @@
+import { AtpAgent } from "@atproto/api";
+export const getAgent = async (props) => {
+    const defaultServiceUrl = props.handle && props.password
+        ? "https://bsky.social"
+        : "https://public.api.bsky.app";
+    const agent = new AtpAgent({
+        service: props.serviceUrl || defaultServiceUrl,
+        fetch: props.$.fetch,
+    });
+    if (props.handle && props.password) {
+        await agent.login({
+            identifier: props.handle,
+            password: props.password,
+        });
+    }
+    return agent;
+};