First upload version 0.0.1

node_modules/node-llama-cpp/dist/utils/transformPromisable.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Transform a value that can be a promise or a value.
+ *
+ * This is used as a performance optimization to avoid adding many microtasks to the event loop,
+ * which makes reading from buffers significantly faster.
+ * @param value - The value to transform, can be a promise or a value
+ * @param transformer - The transformer function
+ * @returns The transformed value. If the input value is a promise, the return value will also be a promise.
+ */
+export declare function transformPromisable<T, R>(value: Promisable<T>, transformer: (value: T) => Promisable<R>): Promisable<R>;
+/**
+ * Transform multiple values that can be promises or values.
+ *
+ * This is used as a performance optimization to avoid adding many microtasks to the event loop,
+ * which makes reading from buffers significantly faster.
+ * @param values - The values to transform, can be promises or values
+ * @param transformer - The transformer function
+ */
+export declare function transformPromisables<const Types extends readonly any[], R>(values: {
+    [Index in keyof Types]: Promisable<Types[Index]>;
+}, transformer: (values: {
+    [Index in keyof Types]: Types[Index];
+}) => Promisable<R>): Promisable<R>;
+/**
+ * An implementation of a loop that waits on promises only when the value is a promise, and otherwise continues synchronously.
+ *
+ * This is a performance optimization to avoid adding many microtasks to the event loop,
+ * which makes reading from buffers significantly faster.
+ */
+export declare function promisableLoop<R>({ condition, callback, afterthought, returnValue }: {
+    /** The condition to check before each iteration */
+    condition: () => Promisable<boolean>;
+    /** The callback to run on each iteration */
+    callback: () => Promisable<void>;
+    /** An afterthought to run after each iteration */
+    afterthought?: () => Promisable<void>;
+    /** The value to return when the loop is done */
+    returnValue: () => Promisable<R>;
+}): Promisable<R>;
+/**
+ * Calls the given getters in order, and when a promise is encountered, waits for it to resolve before continuing.
+ * The result is transformed using the transformer function.
+ *
+ * This is used as a performance optimization to avoid adding many microtasks to the event loop,
+ * which makes reading from buffers significantly faster.
+ * @param getters - An array of functions that return values or promises
+ * @param transformer - The transformer function that takes the promisable values and transforms them into the result of this function
+ */
+export declare function transformPromisablesInOrder<const T extends (() => Promisable<any>)[], const R = {
+    readonly [Index in keyof T]: Awaited<ReturnType<T[Index]>>;
+}>(getters: T, transformer?: (values: {
+    readonly [Index in keyof T]: Awaited<ReturnType<T[Index]>>;
+}) => Promisable<R>): Promisable<R>;
+export type Promisable<T> = T | Promise<T>;