@tstdl/base 0.93.62 → 0.93.66

package/pdf/utils.js

@@ -149,5 +149,5 @@ export async function pdfToImage(file, page, size, format) {
     if (isNotString(file)) {
         process.autoWrite(file);
     }
-    return process.readOutputBytes();
+    return await process.readOutputBytes();
 }

package/schema/converters/zod-converter.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import type { SchemaTestable } from '../schema.js';
 export type SchemaConversionOptions = {
     /** Default coerce option if not specified in schema */

package/schema/converters/zod-converter.js

@@ -1,11 +1,11 @@
 import { match, P } from 'ts-pattern';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { JsonPath } from '../../json-path/json-path.js';
 import { objectEntries, objectKeys } from '../../utils/object/object.js';
 import { isArray, isInstanceOf, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
 import { SchemaError } from '../schema.error.js';
-import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, ConstraintSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, FunctionSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
+import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, ConstraintSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
 import { schemaTestableToSchema } from '../testable.js';
 export function convertToZodSchema(testable, options) {
     const schema = schemaTestableToSchema(testable);
@@ -143,17 +143,6 @@ function convertToZodSchemaBase(schema, options) {
         // enumeration is either EnumerationObject or string-only EnumerationArray, both is fine for z.enum
         // using `as`, as z.enum is overloaded and only one type per overload
         return z.enum(s.enumeration);
-    })
-        .with(P.instanceOf(FunctionSchema), (s) => {
-        let zodSchema = z.function();
-        if (isNotNull(s.parameterSchemas)) {
-            const args = s.parameterSchemas.map((parameterSchema) => convertToZodSchemaBase(parameterSchema, options));
-            zodSchema = zodSchema.input(...args);
-        }
-        if (isNotNull(s.returnValueSchema)) {
-            zodSchema = zodSchema.output(convertToZodSchemaBase(s.returnValueSchema, options));
-        }
-        return zodSchema;
     })
         .with(P.instanceOf(DefaultSchema), (s) => convertToZodSchemaBase(s.schema, options).default(s.defaultValue))
         .with(P.instanceOf(TransformSchema), (s) => convertToZodSchemaBase(s.schema, options).transform((input) => s.transformFn(input)))

package/schema/converters/zod-v3-converter.d.ts

@@ -1,4 +1,4 @@
-import { z, type ZodTypeDef } from 'zod/v3';
+import { type ZodObject, type ZodType, type ZodTypeDef } from 'zod/v3';
 import type { Record } from '../../types/types.js';
 import type { SchemaTestable } from '../schema.js';
 import { ObjectSchema } from '../schemas/index.js';
@@ -9,5 +9,5 @@ export type SchemaConversionOptions = {
     mask?: boolean;
 };
 /** WARNING: *DOES NOT* cover all schemas and options. Meant for usage in schema generators like genkit, not for full schema testing in APIs etc. */
-export declare function convertToZodV3Schema<T extends Record>(testable: ObjectSchema<T>, options?: SchemaConversionOptions): z.ZodObject<any, any, any, T>;
-export declare function convertToZodV3Schema<O, I = unknown>(testable: SchemaTestable<O>, options?: SchemaConversionOptions): z.ZodType<O, ZodTypeDef, I>;
+export declare function convertToZodV3Schema<T extends Record>(testable: ObjectSchema<T>, options?: SchemaConversionOptions): ZodObject<any, any, any, T>;
+export declare function convertToZodV3Schema<O, I = unknown>(testable: SchemaTestable<O>, options?: SchemaConversionOptions): ZodType<O, ZodTypeDef, I>;

package/utils/date-time.d.ts

@@ -56,3 +56,9 @@ export declare function dateTimeToNumericDate(dateTime: DateTime): number;
 export declare function numericDateToDateTime(numericDate: number, units?: DateObjectUnits, options?: DateTimeJSOptions): DateTime;
 export declare function dateTimeToTime(dateTime: DateTime): number;
 export declare function numericDateTimeToDateTime({ date, time }: NumericDateTime, zone?: string): DateTime;
+/** Converts a timestamp, Date, DateTime, ISO date string, or DateObject to a numeric date */
+export declare function toNumericDate(value: number | Date | DateTime | string | DateObject): number;
+export declare function toNumericDate<N extends null | undefined>(value: number | Date | DateTime | string | DateObject | N): number | N;
+/** Converts a numeric date to an ISO date string (YYYY-MM-DD) */
+export declare function numericDateToIsoDate(numericDate: number): string;
+export declare function numericDateToIsoDate<N extends null | undefined>(numericDate: number | N): string | N;

package/utils/date-time.js

@@ -1,6 +1,7 @@
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { DateTime } from 'luxon';
-import { isDate, isNumber } from './type-guards.js';
+import { hasOwnProperty } from './object/object.js';
+import { isDate, isNullOrUndefined, isNumber, isString } from './type-guards.js';
 import { typeOf } from './type-of.js';
 import { millisecondsPerDay, millisecondsPerHour, millisecondsPerMinute, millisecondsPerSecond } from './units.js';
 export function now() {
@@ -126,3 +127,37 @@ export function dateTimeToTime(dateTime) {
 export function numericDateTimeToDateTime({ date, time }, zone) {
     return numericDateToDateTime(date, undefined, { zone }).set({ millisecond: time });
 }
+export function toNumericDate(value) {
+    if (isNullOrUndefined(value)) {
+        return value;
+    }
+    if (isNumber(value)) {
+        return timestampToNumericDate(value);
+    }
+    if (isDate(value)) {
+        return dateToNumericDate(value);
+    }
+    if (DateTime.isDateTime(value)) {
+        return dateTimeToNumericDate(value);
+    }
+    if (isString(value)) {
+        const dateTime = DateTime.fromISO(value, { zone: 'UTC' });
+        if (!dateTime.isValid) {
+            throw new Error(`Invalid ISO date string "${value}": ${dateTime.invalidExplanation}`);
+        }
+        return dateTimeToNumericDate(dateTime);
+    }
+    if (hasOwnProperty(value, 'year') && hasOwnProperty(value, 'month') && hasOwnProperty(value, 'day')) {
+        return dateObjectToNumericDate(value);
+    }
+    throw new NotSupportedError(`Unsupported input type "${typeOf(value)}".`);
+}
+export function numericDateToIsoDate(numericDate) {
+    if (isNullOrUndefined(numericDate)) {
+        return numericDate;
+    }
+    const { year, month, day } = numericDateToDateObject(numericDate);
+    const monthString = month.toString().padStart(2, '0');
+    const dayString = day.toString().padStart(2, '0');
+    return `${year}-${monthString}-${dayString}`;
+}

package/utils/file-reader.d.ts

@@ -1,4 +1,3 @@
 export declare function readAsText(blob: Blob, encoding?: string): Promise<string>;
 export declare function readAsArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
-export declare function readAsBinaryString(blob: Blob): Promise<string>;
 export declare function readAsDataUrl(blob: Blob): Promise<string>;

package/utils/file-reader.js

@@ -1,18 +1,15 @@
 import { DetailsError } from '../errors/details.error.js';
 export async function readAsText(blob, encoding) {
-    return setup((reader) => reader.readAsText(blob, encoding));
+    return await setup((reader) => reader.readAsText(blob, encoding));
 }
 export async function readAsArrayBuffer(blob) {
-    return setup((reader) => reader.readAsArrayBuffer(blob));
-}
-export async function readAsBinaryString(blob) {
-    return setup((reader) => reader.readAsBinaryString(blob));
+    return await setup((reader) => reader.readAsArrayBuffer(blob));
 }
 export async function readAsDataUrl(blob) {
-    return setup((reader) => reader.readAsDataURL(blob));
+    return await setup((reader) => reader.readAsDataURL(blob));
 }
 async function setup(dispatcher) {
-    return new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         const reader = new FileReader();
         reader.onload = () => resolve(reader.result);
         reader.onerror = () => reject(new DetailsError(reader.error.message, reader.error));

package/utils/object/object.d.ts

@@ -30,6 +30,8 @@ export declare function filterNullishObjectProperties<T extends ObjectLiteral>(o
 export declare function copyObjectProperties<T extends ObjectLiteral>(source: T, target: T): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: U, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];
+export declare function assignDeep(target: object, path: JsonPathInput, value: any): void;
+export declare function assignDeepObjectEntries(target: object, entries: readonly (readonly [JsonPathInput, any])[]): void;
 export declare function fromDeepObjectEntries(entries: readonly (readonly [JsonPathInput, any])[]): ObjectLiteral;
-export declare function omit<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Omit<T, K>>;
-export declare function pick<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Pick<T, K>>;
+export declare function omit<T extends Record, K extends keyof T>(object: T, keys: K[]): SimplifyObject<Omit<T, K>>;
+export declare function pick<T extends Record, K extends keyof T>(object: T, keys: K[]): SimplifyObject<Pick<T, K>>;

package/utils/object/object.js

@@ -3,7 +3,7 @@ import { filterAsync } from '../async-iterable-helpers/filter.js';
 import { mapAsync } from '../async-iterable-helpers/map.js';
 import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
 import { toSnakeCase } from '../string/index.js';
-import { isArray, isDefined, isNotNullOrUndefined, isNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
+import { isArray, isDefined, isNotNull, isNotNullOrUndefined, isNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
 export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
@@ -84,7 +84,7 @@ export function getGetter(obj, property, bind) {
         throw new Error(`Property ${property} does not exist.`);
     }
     let objOrPrototype = obj;
-    while (!hasOwnProperty(objOrPrototype, property)) {
+    while (isNotNull(objOrPrototype) && !hasOwnProperty(objOrPrototype, property)) {
         objOrPrototype = Object.getPrototypeOf(objOrPrototype);
     }
     const descriptor = Object.getOwnPropertyDescriptor(objOrPrototype, property);
@@ -123,33 +123,42 @@ export function deepObjectEntries(object, keepInnerObjects = false, prefix) {
     }
     return entries;
 }
-export function fromDeepObjectEntries(entries) {
-    const obj = {};
-    for (const [path, value] of entries) {
-        const jsonPath = JsonPath.from(path);
-        let target = obj;
-        for (let i = 0; i < jsonPath.nodes.length - 1; i++) {
-            const key = jsonPath.nodes[i];
-            if (hasOwnProperty(target, key)) {
-                target = target[key];
-            }
-            else {
-                const child = {};
-                target[key] = child;
-                target = child;
-            }
+export function assignDeep(target, path, value) {
+    const jsonPath = JsonPath.from(path);
+    let currentTarget = target;
+    for (let i = 0; i < jsonPath.nodes.length - 1; i++) {
+        const key = jsonPath.nodes[i];
+        if (key == '__proto__') {
+            throw new Error('Assignment to __proto__ is not allowed for security reasons.');
+        }
+        if (isDefined(currentTarget[key])) {
+            currentTarget = currentTarget[key];
+        }
+        else {
+            const child = {};
+            currentTarget[key] = child;
+            currentTarget = child;
         }
-        target[jsonPath.nodes.at(-1)] = value;
     }
+    currentTarget[jsonPath.nodes.at(-1)] = value;
+}
+export function assignDeepObjectEntries(target, entries) {
+    for (const [path, value] of entries) {
+        assignDeep(target, path, value);
+    }
+}
+export function fromDeepObjectEntries(entries) {
+    const obj = {};
+    assignDeepObjectEntries(obj, entries);
     return obj;
 }
-export function omit(object, ...keys) {
+export function omit(object, keys) {
     return filterObject(object, (_, key) => !keys.includes(key));
 }
-export function pick(object, ...keys) {
+export function pick(object, keys) {
     const result = {};
     for (const key of keys) {
-        if (hasOwnProperty(object, key)) {
+        if (key in object) {
             result[key] = object[key];
         }
     }

package/utils/stream/from-promise.js

@@ -2,8 +2,8 @@ import { resolveValueOrProvider } from '../value-or-provider.js';
 export function readableStreamFromPromise(promiseOrProvider) {
     const stream = new TransformStream();
     resolveValueOrProvider(promiseOrProvider)
-        .then(async (readable) => readable.pipeTo(stream.writable))
-        .catch(async (error) => stream.writable.abort(error).catch(() => { }));
+        .then(async (readable) => await readable.pipeTo(stream.writable))
+        .catch(async (error) => await stream.writable.abort(error).catch(() => { }));
     return stream.readable;
 }
 export function transformStreamFromPromise(promiseOrProvider) {