@tstdl/base 0.92.16 → 0.92.17

package/ai/ai.service.js

@@ -46,7 +46,7 @@ let AiService = class AiService {
             model: options?.model,
             generationOptions: {
                 maxOutputTokens: 1048,
-                temperature: 0.25,
+                temperature: 0.5,
                 ...options
             },
             generationSchema,
@@ -71,7 +71,7 @@ let AiService = class AiService {
         const generation = await this.generate({
             model: options?.model,
             generationOptions: {
-                temperature: 0.25,
+                temperature: 0.5,
                 ...options
             },
             generationSchema: schema,
@@ -107,7 +107,7 @@ Carefully read and analyze the provided document. Identify relevant information
         const generation = await this.generate({
             generationOptions: {
                 maxOutputTokens: 2048,
-                temperature: 0.25,
+                temperature: 0.5,
                 ...options
             },
             generationSchema: schema,
@@ -139,7 +139,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
         const generation = await this.generate({
             model: options.model,
             generationOptions: {
-                temperature: 0.25,
+                temperature: 0.5,
                 ...options
             },
             systemInstruction: options.systemInstruction,

package/authentication/server/authentication.service.d.ts

@@ -1,7 +1,7 @@
-import { AfterResolve, afterResolve } from '../../injector/index.js';
+import { type AfterResolve, afterResolve } from '../../injector/index.js';
 import type { BinaryData, Record } from '../../types.js';
 import type { RefreshToken, SecretCheckResult, SecretResetToken, Token } from '../models/index.js';
-import { SecretTestResult } from './authentication-secret-requirements.validator.js';
+import { type SecretTestResult } from './authentication-secret-requirements.validator.js';
 export type CreateTokenData<AdditionalTokenPayload extends Record> = {
     tokenVersion?: number;
     jwtId?: string;

package/file/mime-type.js

@@ -1,7 +1,5 @@
-import { dynamicImport } from '../import.js';
-import { decodeTextStream } from '../utils/encoding.js';
-import { readTextStream } from '../utils/stream/stream-reader.js';
-import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+import { spawnCommand } from '../process/spawn.js';
+import { isDefined, isString } from '../utils/type-guards.js';
 import { mimeTypesMap } from './mime-types.js';
 export async function getMimeType(file) {
     const path = isString(file) ? file : '-';
@@ -12,22 +10,10 @@ export function getMimeTypeExtensions(mimeType) {
     return mimeTypesMap.get(mimeType) ?? [];
 }
 async function spawnFileCommand(args, file) {
-    const { spawn } = await dynamicImport('node:child_process');
-    const { Readable, Writable } = await dynamicImport('node:stream');
-    const process = spawn('file', args, { stdio: 'pipe' });
-    const stdin = Writable.toWeb(process.stdin);
-    const stdout = Readable.toWeb(process.stdout).pipeThrough(decodeTextStream());
-    if (isReadableStream(file)) {
-        await file.pipeTo(stdin);
-    }
-    else if (isUint8Array(file)) {
-        const writer = stdin.getWriter();
-        try {
-            await writer.write(file);
-            await writer.close();
-        }
-        catch { /* File command closes stream as soon as it has the required data */ }
-    }
-    const output = await readTextStream(stdout);
-    return output.trim();
+    const process = await spawnCommand('file', args, { stdinPipeOptions: { preventCancel: true } });
+    const [stdout] = await Promise.all([
+        process.readOutput(),
+        isDefined(file) ? process.write(file) : undefined
+    ]);
+    return stdout.trim();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.16",
+  "version": "0.92.17",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/pdf/index.d.ts

@@ -1 +1,2 @@
 export * from './pdf.service.js';
+export * from './utils.js';

package/pdf/index.js

@@ -1 +1,2 @@
 export * from './pdf.service.js';
+export * from './utils.js';

package/pdf/utils.d.ts

@@ -0,0 +1 @@
+export declare function getPdfPageCount(file: string): Promise<number>;

package/pdf/utils.js

@@ -0,0 +1,11 @@
+import { spawnCommand } from '../process/spawn.js';
+export async function getPdfPageCount(file) {
+    const process = await spawnCommand('qpdf', ['--show-npages', file]);
+    const { code } = await process.wait();
+    if (code != 0) {
+        const errorOutput = await process.readError();
+        throw new Error(errorOutput.trim());
+    }
+    const output = await process.readOutput();
+    return Number(output);
+}

package/process/spawn.d.ts

@@ -5,11 +5,13 @@ export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
     write(chunk: ReadableStream<Uint8Array> | Uint8Array | string): Promise<void>;
     readOutputBytes(): Promise<Uint8Array>;
     readOutput(): Promise<string>;
-    readErrBytes(): Promise<Uint8Array>;
-    readErr(): Promise<string>;
+    readErrorBytes(): Promise<Uint8Array>;
+    readError(): Promise<string>;
     wait(): Promise<{
         code: number | null;
         signal: string | null;
     }>;
 };
-export declare function spawnCommand(command: string, args: string[]): Promise<SpawnCommandResult>;
+export declare function spawnCommand(command: string, args?: string[], options?: {
+    stdinPipeOptions?: StreamPipeOptions;
+}): Promise<SpawnCommandResult>;

package/process/spawn.js

@@ -3,7 +3,7 @@ import { decodeTextStream, encodeUtf8Stream } from '../utils/encoding.js';
 import { readBinaryStream, readTextStream } from '../utils/stream/stream-reader.js';
 import { toReadableStream } from '../utils/stream/to-readable-stream.js';
 import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
-export async function spawnCommand(command, args) {
+export async function spawnCommand(command, args, options) {
     const { spawn } = await dynamicImport('node:child_process');
     const { Readable, Writable } = await dynamicImport('node:stream');
     const process = spawn(command, args, { stdio: 'pipe' });
@@ -16,13 +16,13 @@ export async function spawnCommand(command, args) {
     const stderr = Readable.toWeb(process.stderr);
     async function write(data) {
         if (isReadableStream(data)) {
-            await data.pipeTo(writable);
+            await data.pipeTo(writable, options?.stdinPipeOptions);
         }
         else if (isUint8Array(data)) {
-            await toReadableStream(data).pipeTo(writable);
+            await toReadableStream(data).pipeTo(writable, options?.stdinPipeOptions);
         }
         else if (isString(data)) {
-            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable);
+            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable, options?.stdinPipeOptions);
         }
     }
     async function readOutputBytes() {
@@ -46,10 +46,10 @@ export async function spawnCommand(command, args) {
         write,
         readOutputBytes,
         readOutput,
-        readErrBytes,
-        readErr,
+        readErrorBytes: readErrBytes,
+        readError: readErr,
         async wait() {
             return signalPromise;
-        },
+        }
     };
 }

package/rpc/rpc.d.ts

@@ -1,4 +1,4 @@
-import type { SerializationOptions } from '../serializer/index.js';
+import { type SerializationOptions } from '../serializer/index.js';
 import type { RpcRemote, RpcRemoteInput } from './model.js';
 import type { RpcAdapter } from './rpc.adapter.js';
 import type { RpcEndpoint } from './rpc.endpoint.js';

package/signals/operators/derive-async.js

@@ -1,4 +1,4 @@
-import { Subject, concatAll, exhaustAll, isObservable, mergeAll, of, switchAll, takeUntil } from 'rxjs';
+import { Subject, concatAll, exhaustAll, from, isObservable, mergeAll, of, switchAll, takeUntil } from 'rxjs';
 import { registerFinalization } from '../../memory/finalization.js';
 import { isPromise } from '../../utils/type-guards.js';
 import { computed, effect, toSignal, untracked } from '../api.js';
@@ -9,15 +9,23 @@ const operatorMap = {
     switch: switchAll,
 };
 export function deriveAsync(source, options) {
-    const outerSource = computed(source);
+    const outerSource = computed(() => {
+        const rawSource = source();
+        if (isPromise(rawSource)) {
+            return from(rawSource);
+        }
+        if (isObservable(rawSource)) {
+            return rawSource;
+        }
+        return of(rawSource);
+    });
     const source$ = new Subject();
     const destroy$ = new Subject();
     const operator = operatorMap[options?.behavior ?? 'switch'];
     const valueSource$ = source$.pipe(operator(), takeUntil(destroy$));
     const result = toSignal(valueSource$, options);
     const effectRef = effect(() => {
-        const rawSource = outerSource();
-        const observableInput = (isPromise(rawSource) || isObservable(rawSource)) ? rawSource : of(rawSource);
+        const observableInput = outerSource();
         untracked(() => source$.next(observableInput));
     });
     registerFinalization(result, () => {

package/utils/type-guards.d.ts

@@ -6,19 +6,7 @@ export type AssertFunction<T> = <U extends T = T>(value: any, message?: Assertio
 export type AssertNotFunction<T> = <V>(value: V, message?: AssertionMessage) => asserts value is Exclude<V, T>;
 export type AssertPassFunction<T> = <U extends T = T>(value: any, message?: AssertionMessage) => U;
 export type AssertNotPassFunction<T> = <V>(value: V, message?: AssertionMessage) => Exclude<V, T>;
-export type GuardFunctions<N extends string, T> = {
-    [P in `is${PascalCase<N>}`]: IsFunction<T>;
-} & {
-    [P in `isNot${PascalCase<N>}`]: IsNotFunction<T>;
-} & {
-    [P in `assert${PascalCase<N>}`]: AssertFunction<T>;
-} & {
-    [P in `assertNot${PascalCase<N>}`]: AssertNotFunction<T>;
-} & {
-    [P in `assert${PascalCase<N>}Pass`]: AssertPassFunction<T>;
-} & {
-    [P in `assertNot${PascalCase<N>}Pass`]: AssertNotPassFunction<T>;
-};
+export type GuardFunctions<N extends string, T> = Record<`is${PascalCase<N>}`, IsFunction<T>> & Record<`isNot${PascalCase<N>}`, IsNotFunction<T>> & Record<`assert${PascalCase<N>}`, AssertFunction<T>> & Record<`assertNot${PascalCase<N>}`, AssertNotFunction<T>> & Record<`assert${PascalCase<N>}Pass`, AssertPassFunction<T>> & Record<`assertNot${PascalCase<N>}Pass`, AssertNotPassFunction<T>>;
 export declare function assert(condition: boolean, message?: AssertionMessage): asserts condition;
 export declare function assertNot(condition: boolean, message?: AssertionMessage): asserts condition;
 export declare function createGuards<N extends string, T>(name: N, testFn: (value: any) => value is T): GuardFunctions<N, T>;