@liase/core 1.0.0

package/dist/LiaseQuery.js

@@ -0,0 +1,145 @@
+import { ZodError, z } from "zod";
+import { finderOptionsSchema } from "./schemas/finderOptions.js";
+import { queryOptionsSchema, } from "./schemas/queryOptions.js";
+import { genericRequestSchema, } from "./schemas/request.js";
+import Liase from "./Liase.js";
+import { generateResponse, getResponseDetailsBasedOnRequest, requestWithDefaults, } from "./generateResponse.js";
+import { exportNetworkRequestsHistoryIfRelevantError } from "./lib/networkRequestsHistory.js";
+import { FriendlyZodError } from "./lib/zod.js";
+const propsSchema = z
+    .object({
+    request: genericRequestSchema,
+    queryOptions: queryOptionsSchema.default({}),
+    finderOptions: finderOptionsSchema.default({}),
+})
+    .strict();
+export default class LiaseQuery extends Liase {
+    #request;
+    #queryOptions;
+    #iterator;
+    constructor(props) {
+        let parsedProps;
+        try {
+            parsedProps = propsSchema.parse(props);
+        }
+        catch (err) {
+            if (err instanceof ZodError) {
+                const error = new FriendlyZodError(err, {
+                    message: "Liase argument invalid",
+                    inputData: props,
+                });
+                throw error;
+            }
+            throw err;
+        }
+        super(parsedProps.finderOptions);
+        this.#request = parsedProps.request;
+        this.#queryOptions = parsedProps.queryOptions;
+        this.#iterator = this.getIterator();
+    }
+    get request() {
+        return { ...this.#request };
+    }
+    get requestWithDefaults() {
+        const requestSchema = this.getRequestSchema();
+        return requestWithDefaults(this.#request, requestSchema);
+    }
+    set request(request) {
+        this.changeRequest(request);
+    }
+    changeRequest(request) {
+        this.rewind();
+        this.#request = genericRequestSchema.parse(request);
+    }
+    async getNext() {
+        const next = await this.#iterator.next();
+        if (next.done) {
+            return null;
+        }
+        return next.value;
+    }
+    rewind() {
+        this.#iterator = this.getIterator();
+    }
+    [Symbol.asyncIterator] = this.getIterator;
+    async *getIterator() {
+        const handler = this.getRequestHandler();
+        const handlerSecretsSchema = handler.secretsSchema;
+        try {
+            if (handlerSecretsSchema) {
+                handlerSecretsSchema.parse(this.#queryOptions.secrets);
+            }
+        }
+        catch (err) {
+            if (err instanceof ZodError) {
+                const error = new FriendlyZodError(err, {
+                    message: "Secrets are invalid",
+                    inputData: this.#queryOptions.secrets,
+                });
+                throw error;
+            }
+            throw err;
+        }
+        let pageFetchedCount = 0;
+        const maxPagesToFetch = this.#queryOptions.fetchCountLimit;
+        while (pageFetchedCount < maxPagesToFetch) {
+            pageFetchedCount++;
+            const parsedRequest = this.requestWithDefaults;
+            const parsedSecrets = handler.secretsSchema?.parse(this.#queryOptions.secrets) ?? {};
+            const pageFetchLimitReached = handler.paginationType === "none"
+                ? undefined
+                : pageFetchedCount === maxPagesToFetch;
+            try {
+                const response = await generateResponse({
+                    requestHandler: handler,
+                    request: parsedRequest,
+                    secrets: parsedSecrets,
+                    responseDetails: this.getResponseDetails(),
+                    pageFetchLimitReached,
+                    cacheNetworkRequests: this.#queryOptions.cacheNetworkRequests,
+                    sourceId: this.getSource(parsedRequest.source).id,
+                    hooks: this._hooks,
+                });
+                if (handler.paginationType === "offset") {
+                    // if paginationType is "offset" then pageNumber must exist due to a check in validateResponse
+                    // in generateResponse.ts but hard to prove that to typescript so we just add an if statement here
+                    // to stop typescript complaining
+                    if (response.page && "pageNumber" in response.page) {
+                        this.#request.pageNumber = response.page.pageNumber + 1;
+                    }
+                }
+                else if (handler.paginationType === "cursor") {
+                    // Same situation as in earlier if statement
+                    if (response.page && "nextCursor" in response.page) {
+                        this.#request.cursor = response.page.nextCursor;
+                    }
+                }
+                yield response;
+                if (handler.paginationType === "none") {
+                    break;
+                }
+                if (response.page?.isLastPage) {
+                    break;
+                }
+            }
+            catch (error) {
+                await exportNetworkRequestsHistoryIfRelevantError(error);
+                throw error;
+            }
+        }
+    }
+    getRequestHandler() {
+        return super.getRequestHandler(this.#request.source, this.#request.queryType);
+    }
+    getRequestSchema() {
+        return super.getRequestSchema(this.#request.source, this.#request.queryType);
+    }
+    getResponseSchema() {
+        return this.getResponseDetails().schema;
+    }
+    getResponseDetails() {
+        const request = this.requestWithDefaults;
+        const responses = this.getRequestHandler().responses;
+        return getResponseDetailsBasedOnRequest(responses, request);
+    }
+}

package/dist/actionHelpers.d.ts

@@ -0,0 +1,30 @@
+export declare function guessMediaInfoFromUrl<AdditionalValues extends {
+    [key: string]: unknown;
+    mimeType?: string;
+    ext?: string;
+    video?: boolean;
+    image?: boolean;
+    audio?: boolean;
+}>(url: string, additionalValues?: AdditionalValues): {
+    url: string;
+    mimeType: string;
+    ext: string;
+    video: boolean;
+    image: boolean;
+    audio?: boolean;
+} & AdditionalValues;
+export declare function guessMediaInfoFromMimeType<AdditionalValues extends {
+    [key: string]: unknown;
+    url?: string;
+    ext?: string;
+    video?: boolean;
+    image?: boolean;
+    audio?: boolean;
+}>(mimeType: string, additionalValues?: AdditionalValues): {
+    mimeType: string;
+    ext: string;
+    video: boolean;
+    image: boolean;
+    audio?: boolean;
+} & AdditionalValues;
+//# sourceMappingURL=actionHelpers.d.ts.map

package/dist/actionHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionHelpers.d.ts","sourceRoot":"","sources":["../src/actionHelpers.ts"],"names":[],"mappings":"AAEA,wBAAgB,qBAAqB,CACnC,gBAAgB,SAAS;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,EAED,GAAG,EAAE,MAAM,EACX,gBAAgB,GAAE,gBAAyC,GAC1D;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,gBAAgB,CAsBnB;AAED,wBAAgB,0BAA0B,CACxC,gBAAgB,SAAS;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,EAED,QAAQ,EAAE,MAAM,EAChB,gBAAgB,GAAE,gBAAyC,GAC1D;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,gBAAgB,CAWnB"}

package/dist/actionHelpers.js

@@ -0,0 +1,73 @@
+import mimeTypes from "mime-types";
+export function guessMediaInfoFromUrl(url, additionalValues = {}) {
+    let ext = additionalValues?.ext || url.match(/\.(\w+)(?:\?[^?]*)?$/)?.[1];
+    let mimeType = additionalValues?.mimeType;
+    if (!mimeType && ext && typeof ext === "string") {
+        mimeType = mimeTypes.lookup(ext) || "";
+    }
+    else if (!ext && mimeType && typeof mimeType === "string") {
+        ext = mimeTypes.extension(mimeType) || "";
+    }
+    if (!ext || !mimeType) {
+        console.info(`url: ${url}\next: ${ext}\nmimeType: ${mimeType}`);
+        throw new Error("Couldn't derive file type");
+    }
+    const { video, image, audio } = guessBasicMediaType({ mimeType, ext });
+    return {
+        url,
+        ext,
+        mimeType,
+        video,
+        image,
+        audio,
+        ...(additionalValues || {}),
+    };
+}
+export function guessMediaInfoFromMimeType(mimeType, additionalValues = {}) {
+    const ext = mimeTypes.extension(mimeType) || "";
+    const { video, image, audio } = guessBasicMediaType({ mimeType, ext });
+    return {
+        ext,
+        mimeType,
+        video,
+        image,
+        audio,
+        ...additionalValues,
+    };
+}
+function guessBasicMediaType({ mimeType, ext, }) {
+    const coreMimeType = mimeType?.split(";")[0].trim().toLowerCase() || "";
+    const coreExt = ext?.trim().toLowerCase() || "";
+    if (coreMimeType.startsWith("video/") ||
+        [
+            "application/x-mpegurl",
+            "application/vnd.apple.mpegurl",
+            "application/mp4",
+            "application/mpeg4-generic",
+            "application/dash+xml",
+            "application/dash-patch+xml",
+        ].includes(coreMimeType) ||
+        coreExt === "gif") {
+        return {
+            video: true,
+            image: false,
+        };
+    }
+    if (coreMimeType.startsWith("image/")) {
+        return {
+            video: false,
+            image: true,
+        };
+    }
+    if (coreMimeType.startsWith("audio/")) {
+        return {
+            video: false,
+            image: false,
+            audio: true,
+        };
+    }
+    if (["application/ogg"].includes(coreMimeType)) {
+        throw new Error(`Unable to determine type of media: ${mimeType || ext}`);
+    }
+    throw new Error(`Resource does not appear to be media: ${mimeType || ext}`);
+}

package/dist/constructorExecution.d.ts

@@ -0,0 +1,7 @@
+import { ActionContext } from "./ActionContext.js";
+import type { Action, Constructor, ConstructorObject } from "./schemas/constructor.js";
+export declare function executeConstructor(constructorDef: Constructor, context: ActionContext): Promise<unknown>;
+export declare function executeConstructorObject(constructorDef: ConstructorObject, context: ActionContext): Promise<unknown>;
+export declare function executeConstructorArray(constructorDef: Array<Constructor>, context: ActionContext): Promise<Array<unknown>>;
+export declare function executeActions(actions: Action[], context: ActionContext): Promise<ActionContext>;
+//# sourceMappingURL=constructorExecution.d.ts.map

package/dist/constructorExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructorExecution.d.ts","sourceRoot":"","sources":["../src/constructorExecution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAsB,MAAM,oBAAoB,CAAC;AAQvE,OAAO,KAAK,EACV,MAAM,EACN,WAAW,EACX,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAIlC,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,WAAW,EAC3B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,OAAO,CAAC,CAwBlB;AAED,wBAAsB,wBAAwB,CAC5C,cAAc,EAAE,iBAAiB,EACjC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,OAAO,CAAC,CA6ElB;AAED,wBAAsB,uBAAuB,CAC3C,cAAc,EAAE,KAAK,CAAC,WAAW,CAAC,EAClC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAiDzB;AA6BD,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,aAAa,CAAC,CAaxB"}

package/dist/constructorExecution.js

@@ -0,0 +1,149 @@
+import { ActionContext, excludeFieldSymbol } from "./ActionContext.js";
+import { DomSelection } from "./DomSelection.js";
+import { ConstructorExecutionError, formatObjectPath, getType, waitForAllPropertiesToResolve, } from "./lib/utils.js";
+const log = [];
+export async function executeConstructor(constructorDef, context) {
+    try {
+        if (!Array.isArray(constructorDef) &&
+            typeof constructorDef === "object" &&
+            !(constructorDef instanceof Date) &&
+            constructorDef !== null) {
+            return executeConstructorObject(constructorDef, context);
+        }
+        if (Array.isArray(constructorDef)) {
+            return executeConstructorArray(constructorDef, context);
+        }
+        if (typeof constructorDef === "function") {
+            return executeAction(constructorDef, context)
+                .then((context) => context.lastResult())
+                .then((result) => result instanceof DomSelection ? result.text : result);
+        }
+        return constructorDef;
+    }
+    catch (error) {
+        handleExecutionError(error, context);
+    }
+}
+export async function executeConstructorObject(constructorDef, context) {
+    let currentContext = context;
+    const topLevelPath = currentContext.path;
+    if (constructorDef._arrayMap) {
+        handleExecutionError(new Error(`Constructor with "_arrayMap" used outside of an array context`), currentContext.clone({ appendToPath: ["_arrayMap"] }));
+    }
+    if (constructorDef._setup) {
+        currentContext = await executeAction(constructorDef._setup, currentContext.clone({ path: [...topLevelPath, "_setup"] }));
+    }
+    const returnObject = {};
+    if (constructorDef._include) {
+        const resultContext = await executeAction(constructorDef._include, currentContext.clone({ path: [...topLevelPath, "_include"] }));
+        const resultValue = resultContext.get("");
+        if (resultValue.constructor !== Object) {
+            throw handleExecutionError(Error(`_include must return a plain object but instead received: ${getType(resultValue)}`), resultContext);
+        }
+        Object.assign(returnObject, resultValue);
+        // We don't want _include to override any value _setup has written to $.get('') but we do
+        // want to keep any values it has written to other non-'' keys.
+        currentContext = currentContext.clone({
+            data: { ...resultContext.getAll(), "": currentContext.get("") },
+        });
+    }
+    const constructorReturnKeys = Object.fromEntries(Object.entries(constructorDef).filter(
+    // Filter out constructor instruction keys
+    ([key]) => !key.match(/^_[^_]/)));
+    for (const key of Object.keys(constructorReturnKeys)) {
+        const value = constructorReturnKeys[key];
+        const newKey = key.replace(/^__/, "_"); // Unescape _ if starts with escaped _
+        returnObject[newKey] = executeConstructor(value, currentContext.clone({ path: [...topLevelPath, key] }));
+    }
+    const awaitedReturnObject = await waitForAllPropertiesToResolve(returnObject);
+    // Remove any fields/array elements who's value is the ExcludeField symbol
+    for (const key of Object.keys(awaitedReturnObject)) {
+        const value = awaitedReturnObject[key];
+        if (value === excludeFieldSymbol) {
+            delete awaitedReturnObject[key];
+        }
+    }
+    return awaitedReturnObject;
+}
+export async function executeConstructorArray(constructorDef, context) {
+    const resultArray = [];
+    for (const [i, element] of constructorDef.entries()) {
+        const elementContext = context.clone({ appendToPath: [i] });
+        // If valueElement is a constructor with a _arrayMap property, get the array returned by _arrayMap and
+        // loop over each element
+        if (!Array.isArray(element) &&
+            typeof element === "object" &&
+            !(element instanceof Date) &&
+            element !== null &&
+            element._arrayMap) {
+            const { _arrayMap, ...constructorWithoutArrayMap } = element;
+            const arrayMapContext = await executeAction(_arrayMap, elementContext.clone({ appendToPath: ["_arrayMap"] }));
+            let elementsToMap;
+            const data = arrayMapContext.get();
+            if (Array.isArray(data)) {
+                elementsToMap = data;
+            }
+            else if (data instanceof DomSelection) {
+                elementsToMap = data.selectedNodes;
+            }
+            else {
+                throw handleExecutionError(new Error(`_arrayMap must return either an array or a DomSelection but instead returned:\n${data}`), arrayMapContext);
+            }
+            for (const elementToMap of elementsToMap) {
+                resultArray.push(executeConstructorObject(constructorWithoutArrayMap, elementContext.clone().set("", elementToMap)));
+            }
+        }
+        else {
+            resultArray.push(executeConstructor(element, elementContext));
+        }
+    }
+    const awaitedReturnArray = await Promise.all(resultArray);
+    // Remove any array elements who's value is the ExcludeField symbol
+    return awaitedReturnArray.filter((element) => element !== excludeFieldSymbol);
+}
+async function executeAction(action, context) {
+    log.push(`Executing action for ${formatObjectPath(context.path)}`);
+    // Actions can be run in parallel and we don't want the execution of one action to modify the context
+    // object and non-deterministically effect the execution of a different action
+    let currentContext = context.clone();
+    try {
+        const result = await action(currentContext);
+        if (result instanceof ActionContext) {
+            // Needed for .chain() to be able to update context by returning cloned context
+            currentContext = result;
+            currentContext.recordResult(undefined);
+        }
+        else {
+            currentContext.recordResult(result);
+        }
+        if (typeof currentContext.lastResult() !== "undefined") {
+            currentContext.set("", currentContext.lastResult());
+        }
+        await currentContext.waitForAllPromisesToResolve();
+    }
+    catch (error) {
+        handleExecutionError(error, currentContext);
+    }
+    return currentContext;
+}
+export async function executeActions(actions, context) {
+    const parentPath = context.path.slice(0, -1);
+    const lastPathSegment = context.path[context.path.length - 1];
+    let currentContext = context;
+    for (const [i, action] of actions.entries()) {
+        currentContext = await executeAction(action, currentContext.clone({
+            path: [...parentPath, `${lastPathSegment} (chain step ${i + 1})`],
+        }));
+    }
+    return currentContext;
+}
+function handleExecutionError(error, actionContext) {
+    if (error instanceof ConstructorExecutionError) {
+        throw error;
+    }
+    throw new ConstructorExecutionError({
+        cause: error instanceof Error ? error : undefined,
+        actionContext,
+        log,
+    });
+}

package/dist/generateResponse.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { GenericRequest } from "./schemas/request.js";
+import type { RequestHandler, requestHandlerSchema } from "./schemas/requestHandler.js";
+import { type GenericResponse } from "./schemas/response.js";
+import type { ConstructorExecutionContext } from "./types.js";
+export declare function generateResponse(constructorContext: ConstructorExecutionContext): Promise<GenericResponse>;
+export declare function getResponseDetailsBasedOnRequest(responses: RequestHandler["responses"], request: GenericRequest): {
+    schema: z.AnyZodObject;
+    description?: string | undefined;
+    requestMatcher?: z.AnyZodObject | undefined;
+    constructor?: import("./index.js").Constructor;
+};
+export declare function requestWithDefaults(request: GenericRequest, requestSchema: z.infer<typeof requestHandlerSchema.shape.requestSchema>): GenericRequest;
+//# sourceMappingURL=generateResponse.d.ts.map

package/dist/generateResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateResponse.d.ts","sourceRoot":"","sources":["../src/generateResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAsB,gBAAgB,CACpC,kBAAkB,EAAE,2BAA2B,GAC9C,OAAO,CAAC,eAAe,CAAC,CAoB1B;AA0DD,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,EACtC,OAAO,EAAE,cAAc;;;;;EAgBxB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,cAAc,EACvB,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,KAAK,CAAC,aAAa,CAAC,GACtE,cAAc,CAahB"}

package/dist/generateResponse.js

@@ -0,0 +1,88 @@
+import assert from "node:assert";
+import { z } from "zod";
+import { ActionContext } from "./ActionContext.js";
+import { executeActions, executeConstructor } from "./constructorExecution.js";
+import { FriendlyZodError, zodParseOrThrow } from "./lib/zod.js";
+import { genericResponseSchema, } from "./schemas/response.js";
+export async function generateResponse(constructorContext) {
+    // If the requestHandler's requestSchema sets any defaults add them to the request
+    const resolvedContext = {
+        ...constructorContext,
+        request: requestWithDefaults(constructorContext.request, constructorContext.requestHandler.requestSchema),
+    };
+    Error.stackTraceLimit = 50;
+    const rootActionContext = new ActionContext({
+        constructorContext: resolvedContext,
+        executeActions,
+        path: [],
+    });
+    const res = await executeConstructor(resolvedContext.responseDetails.constructor, rootActionContext);
+    return await validateResponse(res, resolvedContext, rootActionContext);
+}
+async function validateResponse(
+// biome-ignore lint/suspicious/noExplicitAny: dynamic response object validated by zod
+response, constructorContext, rootActionContext) {
+    const errorMessage = `The response returned from the request handler "${constructorContext.requestHandler.id}" of the source "${constructorContext.sourceId}" is invalid`;
+    const parsedResponse = zodParseOrThrow(genericResponseSchema, response, {
+        errorMessage,
+        context: rootActionContext,
+    });
+    zodParseOrThrow(constructorContext.responseDetails.schema, response, {
+        errorMessage,
+        context: rootActionContext,
+    });
+    assert.deepEqual(constructorContext.request, parsedResponse.request);
+    for (const [index, media] of Object.entries(parsedResponse.media)) {
+        if (media.mediaFinderSource !== constructorContext.sourceId) {
+            throw Error(`Request was for source ${constructorContext.sourceId} but media number ${index} ` +
+                `has source set to ${media.mediaFinderSource}`);
+        }
+    }
+    if (constructorContext.requestHandler.paginationType !== "none") {
+        if (!parsedResponse.page) {
+            throw Error(`Request was for a ${constructorContext.requestHandler.paginationType} page but response has no page`);
+        }
+        if (constructorContext.requestHandler.paginationType !==
+            parsedResponse.page?.paginationType) {
+            throw Error(`Request was for a ${constructorContext.requestHandler.paginationType} page but response page type was ${parsedResponse.page.paginationType}`);
+        }
+        assert.equal(constructorContext.pageFetchLimitReached, parsedResponse.page.pageFetchLimitReached);
+    }
+    else {
+        if (parsedResponse.page) {
+            throw Error("has page");
+        }
+    }
+    return parsedResponse;
+}
+export function getResponseDetailsBasedOnRequest(responses, request) {
+    const response = responses.find((response) => {
+        if (response.requestMatcher) {
+            const { success } = response.requestMatcher.safeParse(request);
+            if (success) {
+                return response;
+            }
+            return undefined;
+        }
+        return response;
+    });
+    if (!response) {
+        throw Error("Could not find matching response details");
+    }
+    return response;
+}
+export function requestWithDefaults(request, requestSchema) {
+    try {
+        return requestSchema.parse(request);
+    }
+    catch (err) {
+        if (err instanceof z.ZodError) {
+            const error = new FriendlyZodError(err, {
+                message: "Request is invalid",
+                inputData: request,
+            });
+            throw error;
+        }
+        throw err;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import LiaseQuery, { type LiaseQueryProps } from "./LiaseQuery.js";
+export { default as Liase } from "./Liase.js";
+export { default as LiaseQuery } from "./LiaseQuery.js";
+export declare function createLiaseQuery(props: LiaseQueryProps): LiaseQuery;
+export type { GenericMedia } from "./schemas/media.js";
+export type { GenericRequest } from "./schemas/request.js";
+export type { GenericResponse } from "./schemas/response.js";
+export type { GenericFile } from "./schemas/file.js";
+export type { Source } from "./schemas/source.js";
+export type { Plugin } from "./schemas/plugin.js";
+export type { RequestHandler } from "./schemas/requestHandler.js";
+export type { Constructor } from "./schemas/constructor.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,EAAE,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEnE,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAExD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,UAAU,CAEnE;AAED,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,YAAY,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,YAAY,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+import LiaseQuery from "./LiaseQuery.js";
+export { default as Liase } from "./Liase.js";
+export { default as LiaseQuery } from "./LiaseQuery.js";
+export function createLiaseQuery(props) {
+    return new LiaseQuery(props);
+}

package/dist/lib/fetch.d.ts

@@ -0,0 +1,10 @@
+type ParsedFetchArgs = {
+    url: URL;
+    method: string;
+    headers: Record<string, string>;
+    body: string | Promise<string>;
+};
+export declare function parseFetchArgs(input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]): ParsedFetchArgs;
+export declare function headersToNormalisedBasicObject(headers: globalThis.Headers | string[][] | Record<string, string | string[] | readonly string[] | undefined>): Record<string, string>;
+export {};
+//# sourceMappingURL=fetch.d.ts.map

package/dist/lib/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/lib/fetch.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,GAAG,EAAE,GAAG,CAAC;IACT,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,EAClC,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,GACjC,eAAe,CA8CjB;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EACH,UAAU,CAAC,OAAO,GAClB,MAAM,EAAE,EAAE,GACV,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC,GAchE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAC5B"}

package/dist/lib/fetch.js

@@ -0,0 +1,68 @@
+export function parseFetchArgs(input, init) {
+    let url;
+    let body;
+    let headers;
+    let method;
+    if (typeof input === "string" || input instanceof URL) {
+        url = input instanceof URL ? input : new URL(input);
+        if (!init || !init.body) {
+            body = "";
+        }
+        else if (init.body instanceof URLSearchParams) {
+            body = init.body.toString();
+        }
+        else if (init.body instanceof FormData) {
+            body = init.body.toString();
+        }
+        else if (init.body instanceof ArrayBuffer) {
+            body = new TextDecoder().decode(init.body);
+        }
+        else if (ArrayBuffer.isView(init.body)) {
+            body = new TextDecoder().decode(init.body);
+        }
+        else if (init.body instanceof Blob) {
+            body = init.body.text();
+        }
+        else if (init.body instanceof ReadableStream) {
+            body = new Response(init.body).text();
+        }
+        else if (typeof init.body === "object") {
+            throw Error("Only string, URLSearchParams, FormData, ArrayBuffer, ArrayBufferView, Blob, and ReadableStream type bodies are currently supported. Sorry!");
+        }
+        else {
+            body = init.body;
+        }
+        headers = headersToNormalisedBasicObject(init?.headers ?? {});
+        method = init?.method ?? "";
+    }
+    else if (input instanceof Request) {
+        const clonedRequest = input.clone();
+        url = new URL(clonedRequest.url);
+        body = clonedRequest.text();
+        headers = headersToNormalisedBasicObject(clonedRequest.headers);
+        method = clonedRequest.method;
+    }
+    else {
+        input;
+        throw Error("Input is invalid");
+    }
+    return {
+        url,
+        body,
+        headers,
+        method,
+    };
+}
+export function headersToNormalisedBasicObject(headers) {
+    let entries;
+    if (Array.isArray(headers)) {
+        entries = headers;
+    }
+    else if (headers instanceof global.Headers) {
+        entries = [...headers.entries()];
+    }
+    else {
+        entries = Object.entries(headers);
+    }
+    return Object.fromEntries(entries.map((entry) => [entry[0].toLocaleLowerCase(), entry[1]]));
+}

package/dist/lib/hooks.d.ts

@@ -0,0 +1,7 @@
+export type Hook = (input: any, next: (output: any) => any) => any;
+export type LiaseHooks = {
+    loadUrl: Array<Hook>;
+    getFetchClient: Array<Hook>;
+};
+export declare function executeHooks(input: any, hooks: Array<Hook>): Promise<any>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/lib/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/lib/hooks.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,IAAI,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG,CAAC;AAEnE,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IACrB,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;CAC7B,CAAC;AAGF,wBAAsB,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,gBAWhE"}

package/dist/lib/hooks.js

@@ -0,0 +1,13 @@
+// biome-ignore lint/suspicious/noExplicitAny: hooks pipeline passes arbitrary data between middleware
+export async function executeHooks(input, hooks) {
+    const hooksIterator = hooks.values();
+    // biome-ignore lint/suspicious/noExplicitAny: hooks pipeline passes arbitrary data between middleware
+    async function runNextHook(input) {
+        const nextHook = hooksIterator.next().value;
+        if (!nextHook) {
+            return input;
+        }
+        return nextHook(await input, runNextHook);
+    }
+    return await runNextHook(await input);
+}