@tstdl/base 0.93.125 → 0.93.127

package/ai/functions.js

@@ -1,38 +0,0 @@
-import { convertToOpenApiSchema } from '../schema/converters/open-api-converter.js';
-import { FunctionSchema, getObjectSchema, object } from '../schema/index.js';
-import { fromEntries, objectEntries } from '../utils/object/object.js';
-import { isNotNull, isNull, isString } from '../utils/type-guards.js';
-/**
- * Extracts Google AI function declarations from a class decorated with schema information.
- * It iterates over the properties of the class schema and converts `FunctionSchema` instances
- * into the format required by the Google Generative AI API.
- * @param type The constructor of the class to extract function declarations from.
- */
-export function getFunctionDeclarations(type) {
-    const objectSchema = getObjectSchema(type);
-    return objectEntries(objectSchema.properties)
-        .map(([key, schema]) => {
-        if (!(schema instanceof FunctionSchema)) {
-            return null;
-        }
-        return {
-            name: `${type.name}.${key}`,
-            description: schema.description ?? undefined,
-            parameters: isNull(schema.parameterSchemas)
-                ? undefined
-                : getFunctionDeclarationParameters(schema),
-        };
-    })
-        .filter(isNotNull);
-}
-function getFunctionDeclarationParameters(functionSchema) {
-    const entries = functionSchema.parameterSchemas.map((schema, index) => {
-        const parameterName = functionSchema.parameterNames[index];
-        if (!isString(parameterName)) {
-            throw new Error(`Parameter ${index} requires a name.`);
-        }
-        return [parameterName, schema];
-    });
-    const parametersSchema = object(fromEntries(entries));
-    return convertToOpenApiSchema(parametersSchema);
-}

package/ai/module.d.ts

@@ -1,26 +0,0 @@
-import type { AiModel } from './types.js';
-/**
- * Options for configuring the AI Module.
- */
-export declare class AiModuleOptions {
-    /** Google AI API key. */
-    apiKey?: string;
-    /** Path to the Google Cloud credentials file. */
-    keyFile?: string;
-    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
-    vertex?: {
-        project: string;
-        location: string;
-        bucket?: string;
-    };
-    /**
-     * The default model to use for generation requests.
-     * @default 'small'
-     */
-    defaultModel?: AiModel;
-}
-/**
- * Configures the {@link AiService}.
- * @param options The configuration options for the AI services.
- */
-export declare function configureAiService(options: AiModuleOptions): void;

package/ai/module.js

@@ -1,25 +0,0 @@
-import { Injector } from '../injector/injector.js';
-/**
- * Options for configuring the AI Module.
- */
-export class AiModuleOptions {
-    /** Google AI API key. */
-    apiKey;
-    /** Path to the Google Cloud credentials file. */
-    keyFile;
-    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
-    vertex;
-    /**
-     * The default model to use for generation requests.
-     * @default 'small'
-     */
-    defaultModel;
-}
-;
-/**
- * Configures the {@link AiService}.
- * @param options The configuration options for the AI services.
- */
-export function configureAiService(options) {
-    Injector.register(AiModuleOptions, { useValue: options });
-}

package/ai/types.d.ts

@@ -1,229 +0,0 @@
-import type { LiteralUnion } from 'type-fest';
-import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../schema/index.js';
-import type { Record, UndefinableJsonObject } from '../types/index.js';
-import type { ResolvedValueOrProvider, ValueOrAsyncProvider } from '../utils/value-or-provider.js';
-/**
- * Represents a file to be uploaded, either from a local path or as a `Blob`.
- */
-export type FileInput = {
-    path: string;
-    mimeType: string;
-} | {
-    stream: ReadableStream<Uint8Array>;
-    mimeType: string;
-    size?: number;
-} | Blob;
-/**
- * A record of named function declarations, where each key is the function name.
- */
-export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaration<any>>;
-/**
- * A function declaration that only defines the function's signature (name, description, parameters).
- * @template T The record type for the function's parameters.
- */
-export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
-    description: string;
-    parameters?: ValueOrAsyncProvider<ObjectSchema<T>>;
-    enabled?: ValueOrAsyncProvider<boolean>;
-};
-/**
- * A function declaration that includes a handler to be executed when the function is called by the model.
- * @template T The record type for the function's parameters.
- * @template R The return type of the handler.
- */
-export type SchemaFunctionDeclarationWithHandler<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> & {
-    handler: (parameters: T) => R | Promise<R>;
-};
-/**
- * A union of a function declaration with or without a handler.
- * @template T The record type for the function's parameters.
- * @template R The return type of the handler if it exists.
- */
-export type SchemaFunctionDeclaration<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> | SchemaFunctionDeclarationWithHandler<T, R>;
-/**
- * Extracts the return type of a function declaration's handler.
- * If the declaration has no handler, it resolves to `never`.
- * @template T The function declaration type.
- */
-export type SchemaFunctionDeclarationHandlerResult<T extends SchemaFunctionDeclaration> = T extends SchemaFunctionDeclarationWithHandler<any, infer R> ? R : never;
-/**
- * Represents the result of a function call, typed based on the provided declarations.
- * This is a distributive conditional type that maps over the function declarations.
- * @template T The schema declarations for the available functions.
- */
-export type SchemaFunctionDeclarationsResult<T extends SchemaFunctionDeclarations = SchemaFunctionDeclarations> = {
-    [P in keyof T]: {
-        /** The name of the function that was called. */
-        functionName: P;
-        /** The parameters passed to the function call, parsed against the schema. */
-        parameters: SchemaOutput<NonNullable<ResolvedValueOrProvider<T[P]['parameters']>>>;
-        /** The result of executing the handler, if one was provided. */
-        handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
-        /** A function to get the content part representing the function result, for use in subsequent AI requests. */
-        getFunctionResultContentPart: () => FunctionResultContentPart;
-    };
-}[keyof T];
-/**
- * The role of the author of a piece of content.
- */
-export type ContentRole = 'user' | 'model';
-/** A part of a `Content` object containing text. */
-export type TextContentPart = {
-    text: string;
-};
-/** A part of a `Content` object referencing a processed file via its ID. */
-export type FileContentPart = {
-    file: string;
-};
-/** Represents a function call requested by the model. */
-export type FunctionCall = {
-    name: string;
-    parameters: UndefinableJsonObject;
-};
-/** A part of a `Content` object representing a function call request from the model. */
-export type FunctionCallContentPart = {
-    functionCall: FunctionCall;
-};
-/** The result of a function execution. */
-export type FunctionResult = {
-    name: string;
-    value: UndefinableJsonObject;
-};
-/** A part of a `Content` object representing the result of a function call. */
-export type FunctionResultContentPart = {
-    functionResult: FunctionResult;
-};
-/** A union of all possible content part types. */
-export type ContentPart = TextContentPart | FileContentPart | FunctionCallContentPart | FunctionResultContentPart;
-/** A single message in a conversation, containing a role and one or more parts. */
-export type Content = {
-    role: ContentRole;
-    parts: readonly ContentPart[];
-};
-/**
- * Specifies the mode for function calling.
- * - `auto`: The model decides whether to call a function.
- * - `force`: The model is forced to call a function.
- * - `none`: The model will not call any functions.
- */
-export type FunctionCallingMode = 'auto' | 'force' | 'none';
-/**
- * The reason why the model stopped generating content.
- */
-export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
-/**
- * The specific AI model to use for a request.
- *
- * Aliases `small`, `medium`, and `large` map to models that change over time.
- */
-export type AiModel = LiteralUnion<'small' | 'medium' | 'large' | 'gemini-flash-latest' | 'gemini-flash-lite-latest' | 'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite', string>;
-/**
- * Options to control the generation process.
- */
-export type GenerationOptions = {
-    /** The maximum number of tokens to generate in the response. */
-    maxOutputTokens?: number;
-    /** Controls the randomness of the output. Higher values (closer to 1.0) make the output more random. */
-    temperature?: number;
-    /** The cumulative probability of tokens to consider for sampling. */
-    topP?: number;
-    /** The number of highest-probability tokens to consider for sampling. */
-    topK?: number;
-    /** A penalty for tokens that have already appeared in the text. */
-    presencePenalty?: number;
-    /** A penalty for tokens based on their frequency in the text. */
-    frequencyPenalty?: number;
-    /**
-     * The maximum number of tokens the model is allowed to generate for its thinking phase.
-     */
-    thinkingBudget?: number;
-    /**
-     * Whether to include the model's internal thoughts in the response.
-     */
-    includeThoughts?: boolean;
-};
-/**
- * A request to generate content from the AI model.
- * @template S The expected type of the `json` property in the result if `generationSchema` is provided.
- */
-export type GenerationRequest<S = unknown> = {
-    /** The model to use for the request. If not provided, a default will be used. */
-    model?: AiModel;
-    /** A system instruction to guide the model's behavior. */
-    systemInstruction?: string;
-    /** The content or conversation history to send to the model. */
-    contents: Content | readonly Content[];
-    /** A set of functions the model can call. */
-    functions?: SchemaFunctionDeclarations;
-    /** The mode for function calling. */
-    functionCallingMode?: FunctionCallingMode;
-    /** A schema to which the model's output should conform. Implies `responseMimeType: 'application/json'`. */
-    generationSchema?: SchemaTestable<S>;
-    /** Options to control the generation process. */
-    generationOptions?: GenerationOptions;
-};
-/**
- * Token usage statistics for a generation request.
- */
-export type GenerationUsage = {
-    /** The number of generation iterations (usually 1, more if `maxOutputTokens` is hit and generation continues). */
-    iterations: number;
-    /** Tokens cached.  */
-    cached: number;
-    /** Tokens used in the prompt. */
-    prompt: number;
-    /** Tokens used for internal thoughts. */
-    thoughts: number;
-    /** Tokens in the generated output. */
-    output: number;
-    /** Tokens used for tools. */
-    tools: number;
-    /** Total tokens used. */
-    total: number;
-};
-/**
- * The result of a generation request.
- * @template S The expected type of the `json` property if a schema was provided in the request.
- */
-export type GenerationResult<S = unknown> = {
-    /** The content generated by the model. */
-    content: Content;
-    /** The complete text generated by the model, or `null` if no text was generated. */
-    text: string | null;
-    /** The text parsed as JSON, conforming to the provided schema. `undefined` if no schema was provided. */
-    json: S;
-    /** An array of function calls requested by the model. */
-    functionCalls: FunctionCall[];
-    /** The reason why the model stopped generating. */
-    finishReason: FinishReason;
-    /** Token usage statistics for the request. */
-    usage: GenerationUsage;
-};
-/**
- * A helper function to define a set of function declarations with strong type inference.
- * @param declarations A record of function declarations.
- * @returns The same record of declarations, with types preserved.
- */
-export declare function defineFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;
-/**
- * A helper function to define a single function declaration with strong type inference,
- * particularly for its parameters.
- * @param declaration The function declaration.
- * @returns The same declaration, with types preserved.
- */
-export declare function defineFunction<P extends Record, T extends SchemaFunctionDeclaration<P>>(declaration: T & Pick<SchemaFunctionDeclaration<P>, 'parameters'>): T;
-/**
- * A type guard to check if a function declaration includes a handler.
- * @param declaration The function declaration to check.
- * @returns `true` if the declaration has a `handler` property, `false` otherwise.
- */
-export declare function isSchemaFunctionDeclarationWithHandler(declaration: SchemaFunctionDeclaration): declaration is SchemaFunctionDeclarationWithHandler;
-export declare function isPathFileInput(input: FileInput): input is {
-    path: string;
-    mimeType: string;
-};
-export declare function isStreamFileInput(input: FileInput): input is {
-    stream: ReadableStream<Uint8Array>;
-    mimeType: string;
-    size?: number;
-};

package/ai/types.js

@@ -1,33 +0,0 @@
-import { hasOwnProperty } from '../utils/object/object.js';
-import { isBlob } from '../utils/type-guards.js';
-/**
- * A helper function to define a set of function declarations with strong type inference.
- * @param declarations A record of function declarations.
- * @returns The same record of declarations, with types preserved.
- */
-export function defineFunctions(declarations) {
-    return declarations;
-}
-/**
- * A helper function to define a single function declaration with strong type inference,
- * particularly for its parameters.
- * @param declaration The function declaration.
- * @returns The same declaration, with types preserved.
- */
-export function defineFunction(declaration) {
-    return declaration;
-}
-/**
- * A type guard to check if a function declaration includes a handler.
- * @param declaration The function declaration to check.
- * @returns `true` if the declaration has a `handler` property, `false` otherwise.
- */
-export function isSchemaFunctionDeclarationWithHandler(declaration) {
-    return hasOwnProperty(declaration, 'handler');
-}
-export function isPathFileInput(input) {
-    return !isBlob(input) && hasOwnProperty(input, 'path');
-}
-export function isStreamFileInput(input) {
-    return !isBlob(input) && hasOwnProperty(input, 'stream');
-}

package/latex/index.d.ts

@@ -1 +0,0 @@
-export * from './render.js';

package/latex/index.js

@@ -1 +0,0 @@
-export * from './render.js';

package/typst/index.d.ts

@@ -1 +0,0 @@
-export * from './render.js';

package/typst/index.js

@@ -1 +0,0 @@
-export * from './render.js';

package/typst/render.d.ts

@@ -1,23 +0,0 @@
-export type TypstRenderOptions = {
-    /**
-     * The root directory for resolving imports in the Typst source. If not specified, imports will be resolved relative to the location of the source file.
-     */
-    root?: string;
-    /**
-     * The output format for the rendered document.
-     * Note: `docx` output uses pandoc under the hood, which does not support all Typst features.
-     * @default 'pdf'
-     */
-    format?: 'pdf' | 'png' | 'svg' | 'html' | 'docx';
-};
-/**
- * Renders Typst source code to a file in the specified format.
- *
- * ## WARNING
- * **This function should not be used with untrusted typst source, as it can lead to arbitrary code execution on the system.**
- *
- * Requires typst to be installed on the system.
- * @param source
- * @param options
- */
-export declare function renderTypst(source: string, options?: TypstRenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/typst/render.js

@@ -1,32 +0,0 @@
-import { spawnCommand } from '../process/spawn.js';
-import { decodeText } from '../utils/encoding.js';
-/**
- * Renders Typst source code to a file in the specified format.
- *
- * ## WARNING
- * **This function should not be used with untrusted typst source, as it can lead to arbitrary code execution on the system.**
- *
- * Requires typst to be installed on the system.
- * @param source
- * @param options
- */
-export async function renderTypst(source, options) {
-    const format = options?.format ?? 'pdf';
-    const command = (format == 'docx') ? 'pandoc' : 'typst';
-    const args = (format == 'docx')
-        ? ['--from', 'typst', '--to', 'docx', '--output', '-', '-']
-        : ['compile', '--format', format, '-', '-'];
-    const process = await spawnCommand(command, args);
-    const [{ code, output, error }] = await Promise.all([
-        process.waitRead('binary', { throwOnNonZeroExitCode: false }),
-        process.write(source),
-    ]);
-    const errorString = decodeText(error);
-    if (code !== 0) {
-        throw new Error(`
-Typst compilation failed with exit code ${code}.\n
-Error Output:\n${errorString}
-`.trim());
-    }
-    return output;
-}