@adviser/cement 0.0.0-jsr-t1

package/index.d.cts

@@ -0,0 +1,532 @@
+import { S as SysAbstraction, T as Time } from './base-sys-abstraction-Qj7pkY1N.cjs';
+export { r as BaseSysAbstraction, o as BaseSysAbstractionParams, B as BrowserEnvActions, C as ConstTime, D as Duration, f as Env, d as EnvActions, e as EnvFactoryOpts, h as EnvImpl, E as EnvMap, p as ExitHandler, q as ExitService, F as FileService, I as IDMode, n as IdService, N as NamedWritableStream, O as OnSetItem, R as RandomMode, m as RandomService, k as StepTime, b as String2TimeMode, j as SysTime, c as SystemService, l as TimeFactory, a as TimeMode, i as TimeUnits, V as VoidFunc, s as WrapperSysAbstraction, W as WrapperSysAbstractionParams, g as envFactory } from './base-sys-abstraction-Qj7pkY1N.cjs';
+import { T as TxtEnDecoder } from './txt-en-decoder-CZYJUju2.cjs';
+export { U as Utf8EnDecoder, a as Utf8EnDecoderSingleton } from './txt-en-decoder-CZYJUju2.cjs';
+export { i as utils } from './index-Q3phXzYr.cjs';
+
+declare abstract class Result<T, E = Error> {
+    static Ok<T = void>(t: T): Result<T, Error>;
+    static Err<T, E extends Error = Error>(t: E | string): Result<T, E>;
+    static Is<T>(t: unknown): t is Result<T>;
+    isOk(): boolean;
+    isErr(): boolean;
+    Ok(): T;
+    Err(): E;
+    abstract is_ok(): boolean;
+    abstract is_err(): boolean;
+    abstract unwrap(): T;
+    abstract unwrap_err(): E;
+}
+declare class ResultOK<T> extends Result<T, Error> {
+    private _t;
+    constructor(t: T);
+    is_ok(): boolean;
+    is_err(): boolean;
+    unwrap_err(): Error;
+    unwrap(): T;
+}
+declare class ResultError<T extends Error> extends Result<never, T> {
+    private _error;
+    constructor(t: T);
+    is_ok(): boolean;
+    is_err(): boolean;
+    unwrap(): never;
+    unwrap_err(): T;
+}
+type WithoutResult<T> = T extends Result<infer U> ? U : T;
+type WithResult<T> = T extends Promise<infer U> ? Promise<Result<U>> : Result<T>;
+declare function exception2Result<FN extends () => Promise<T> | T, T>(fn: FN): WithResult<ReturnType<FN>>;
+
+type NullOrUndef = null | undefined;
+declare function isURL(value: unknown): value is URL;
+declare class MutableURL extends URL {
+    private readonly _sysURL;
+    private _protocol;
+    private _pathname;
+    private _hasHostpart;
+    readonly hash: string;
+    constructor(urlStr: string);
+    clone(): MutableURL;
+    get host(): string;
+    get port(): string;
+    set port(p: string);
+    get hostname(): string;
+    set hostname(h: string);
+    set pathname(p: string);
+    get pathname(): string;
+    get protocol(): string;
+    set protocol(p: string);
+    get searchParams(): URLSearchParams;
+    toString(): string;
+}
+declare class BuildURI {
+    _url: MutableURL;
+    private constructor();
+    static is(value: unknown): value is BuildURI;
+    static from(strURLUri?: CoerceURI, defaultProtocol?: string): BuildURI;
+    port(p: string): BuildURI;
+    hostname(h: string): BuildURI;
+    protocol(p: string): BuildURI;
+    pathname(p: string): BuildURI;
+    delParam(key: string): BuildURI;
+    defParam(key: string, str: string): BuildURI;
+    setParam(key: string, str: string): BuildURI;
+    hasParam(key: string): boolean;
+    getParam(key: string): string | undefined;
+    toString(): string;
+    toJSON(): string;
+    URI(): URI;
+}
+type CoerceURI = string | URI | MutableURL | URL | BuildURI | NullOrUndef;
+declare const protocols: Set<string>;
+declare class URI {
+    static protocolHasHostpart(protocol: string): () => void;
+    static merge(into: CoerceURI, from: CoerceURI, defaultProtocol?: string): URI;
+    static is(value: unknown): value is URI;
+    static from(strURLUri?: CoerceURI, defaultProtocol?: string): URI;
+    static fromResult(strURLUri?: CoerceURI, defaultProtocol?: string): Result<URI>;
+    readonly _url: MutableURL;
+    private constructor();
+    build(): BuildURI;
+    get hostname(): string;
+    get port(): string;
+    get host(): string;
+    get protocol(): string;
+    get pathname(): string;
+    get getParams(): Iterable<[string, string]>;
+    hasParam(key: string): boolean;
+    getParam(key: string): string | undefined;
+    clone(): URI;
+    asURL(): URL;
+    toString(): string;
+    toJSON(): string;
+}
+
+declare enum Level {
+    WARN = "warn",
+    DEBUG = "debug",
+    INFO = "info",
+    ERROR = "error"
+}
+type Serialized = string | number | boolean;
+type FnSerialized = () => Serialized | Serialized[];
+declare class LogValue {
+    readonly fn: FnSerialized;
+    constructor(fn: FnSerialized);
+    value(): Serialized | Serialized[];
+    toJSON(): Serialized | Serialized[];
+}
+type LogSerializable = Record<string, LogValue | Promise<LogValue>>;
+declare function removeSelfRef(lineEnd?: string): (key: unknown, val: unknown) => unknown;
+declare function asyncLogValue(val: () => Promise<Serialized>): Promise<LogValue>;
+type LogValueArg = LogValue | Serialized | Serialized[] | FnSerialized | undefined | null;
+declare function logValue(val: LogValueArg, state?: Set<unknown>): LogValue;
+interface Sized {
+    size: number;
+}
+interface Lengthed {
+    length: number;
+}
+type SizeOrLength = Sized | Lengthed;
+interface LogFormatter {
+    format(attr: LogSerializable): Uint8Array;
+}
+interface LevelHandler {
+    enableLevel(level: Level, ...modules: string[]): void;
+    disableLevel(level: Level, ...modules: string[]): void;
+    setExposeStack(enable?: boolean): void;
+    isStackExposed: boolean;
+    setDebug(...modules: (string | string[])[]): void;
+    isEnabled(ilevel: unknown, module: unknown): boolean;
+}
+interface LoggerInterface<R> {
+    TxtEnDe(): TxtEnDecoder;
+    Module(key: string): R;
+    EnableLevel(level: Level, ...modules: string[]): R;
+    DisableLevel(level: Level, ...modules: string[]): R;
+    Attributes(): Record<string, unknown>;
+    SetDebug(...modules: (string | string[])[]): R;
+    SetExposeStack(enable?: boolean): R;
+    SetFormatter(fmt: LogFormatter): R;
+    Ref(key: string, action: {
+        toString: () => string;
+    } | FnSerialized): R;
+    Result<T>(key: string, res: Result<T>): R;
+    Url(url: CoerceURI, key?: string): R;
+    Len(value: unknown, key?: string): R;
+    Hash(value: unknown, key?: string): R;
+    Str(key: string, value?: string): R;
+    Error(): R;
+    Warn(): R;
+    Debug(): R;
+    Log(): R;
+    WithLevel(level: Level): R;
+    Err(err: unknown | Result<unknown> | Error): R;
+    Info(): R;
+    Timestamp(): R;
+    Any(key: string, value: unknown): R;
+    Dur(key: string, nsec: number): R;
+    Uint64(key: string, value: number): R;
+    Int(key: string, value: number): R;
+    Bool(key: string, value: unknown): R;
+}
+declare function IsLogger(obj: unknown): obj is Logger;
+interface WithLogger extends LoggerInterface<WithLogger> {
+    Logger(): Logger;
+}
+interface AsError {
+    AsError(): Error;
+}
+interface Logger extends LoggerInterface<Logger> {
+    With(): WithLogger;
+    Msg(...args: string[]): AsError;
+    Flush(): Promise<void>;
+}
+
+declare class LogWriterStream {
+    readonly _out: WritableStream<Uint8Array>;
+    readonly _toFlush: (() => Promise<void>)[];
+    constructor(out: WritableStream<Uint8Array>);
+    write(encoded: Uint8Array): void;
+    _flushIsRunning: boolean;
+    _flushDoneFns: (() => void)[];
+    _flush(toFlush?: (() => Promise<void>)[] | undefined, done?: () => void): void;
+}
+
+declare class JSONFormatter implements LogFormatter {
+    private readonly _txtEnDe;
+    private readonly _space?;
+    constructor(txtEnde: TxtEnDecoder, space?: number);
+    format(attr: LogSerializable): Uint8Array;
+}
+declare class YAMLFormatter implements LogFormatter {
+    private readonly _txtEnDe;
+    private readonly _space?;
+    constructor(txtEnde: TxtEnDecoder, space?: number);
+    format(attr: LogSerializable): Uint8Array;
+}
+interface LoggerImplParams {
+    readonly out?: WritableStream<Uint8Array>;
+    readonly logWriter?: LogWriterStream;
+    readonly sys?: SysAbstraction;
+    readonly withAttributes?: LogSerializable;
+    readonly levelHandler?: LevelHandler;
+    readonly txtEnDe?: TxtEnDecoder;
+    readonly formatter?: LogFormatter;
+}
+declare class LoggerImpl implements Logger {
+    readonly _sys: SysAbstraction;
+    readonly _attributes: LogSerializable;
+    readonly _withAttributes: LogSerializable;
+    readonly _logWriter: LogWriterStream;
+    readonly _levelHandler: LevelHandler;
+    readonly _txtEnDe: TxtEnDecoder;
+    _formatter: LogFormatter;
+    constructor(params?: LoggerImplParams);
+    TxtEnDe(): TxtEnDecoder;
+    Attributes(): Record<string, unknown>;
+    SetExposeStack(enable?: boolean): Logger;
+    EnableLevel(level: Level, ...modules: string[]): Logger;
+    DisableLevel(level: Level, ...modules: string[]): Logger;
+    Module(key: string): Logger;
+    SetDebug(...modules: (string | string[])[]): Logger;
+    SetFormatter(formatter: LogFormatter): Logger;
+    Timestamp(): Logger;
+    Warn(): Logger;
+    Log(): Logger;
+    Debug(): Logger;
+    Error(): Logger;
+    Info(): Logger;
+    Err(err: unknown | Result<unknown> | Error): Logger;
+    WithLevel(l: Level): Logger;
+    Ref(key: string, action: {
+        toString: () => string;
+    } | FnSerialized): Logger;
+    Bool(key: string, value: unknown): Logger;
+    Result<T>(key: string, res: Result<T, Error>): Logger;
+    Len(value: unknown, key?: string): Logger;
+    Hash(value: unknown, key?: string): Logger;
+    Url(url: CoerceURI, key?: string): Logger;
+    Str(key: string, value?: string): Logger;
+    Any(key: string, value?: string | number | boolean | LogSerializable): Logger;
+    Dur(key: string, nsec: number): Logger;
+    Uint64(key: string, value: number): Logger;
+    Int(key: string, value: number): Logger;
+    Flush(): Promise<void>;
+    With(): WithLogger;
+    _resetAttributes(fn: () => () => Uint8Array): () => Uint8Array;
+    Msg(...args: string[]): AsError;
+}
+
+declare class Future<T> {
+    #private;
+    constructor();
+    asPromise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}
+
+declare class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
+    private readonly _bufferArr;
+    constructor(bufferArr: Uint8Array[]);
+    readonly _resolveClosed: Future<undefined>;
+    readonly closed: Promise<undefined>;
+    readonly desiredSize: number | null;
+    readonly ready: Promise<undefined>;
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    releaseLock(): void;
+    write(chunk?: Uint8Array): Promise<void>;
+}
+declare class LogCollector implements WritableStream<Uint8Array> {
+    readonly locked: boolean;
+    private _writer?;
+    private readonly _pass?;
+    private readonly _bufferArr;
+    private readonly _txtEnDe;
+    constructor(pass?: WritableStreamDefaultWriter<Uint8Array>, txtEnDe?: TxtEnDecoder);
+    abort(reason?: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+    getWriter(): WritableStreamDefaultWriter<Uint8Array>;
+    Logs(notJsonLine?: boolean): any[];
+}
+
+interface MockLoggerReturn {
+    readonly logger: Logger;
+    readonly logCollector: LogCollector;
+}
+declare function MockLogger(params?: {
+    readonly sys?: SysAbstraction;
+    readonly pass?: WritableStreamDefaultWriter<Uint8Array>;
+    moduleName?: string | string[];
+    readonly disableDebug?: boolean;
+}): MockLoggerReturn;
+
+declare class LevelHandlerImpl implements LevelHandler {
+    readonly _globalLevels: Set<Level>;
+    readonly _modules: Map<string, Set<Level>>;
+    isStackExposed: boolean;
+    enableLevel(level: Level, ...modules: string[]): void;
+    disableLevel(level: Level, ...modules: string[]): void;
+    setExposeStack(enable?: boolean): void;
+    forModules(level: Level, fnAction: (p: string) => void, ...modules: (string | string[])[]): void;
+    setDebug(...modules: (string | string[])[]): void;
+    isEnabled(ilevel: unknown, module: unknown): boolean;
+}
+declare function LevelHandlerSingleton(): LevelHandler;
+
+declare abstract class Option<T> {
+    static Some<T>(t: T): Option<T>;
+    static None<T>(): Option<T>;
+    static Is<T>(t: unknown): t is Option<T>;
+    IsNone(): boolean;
+    IsSome(): boolean;
+    Unwrap(): T;
+    abstract is_none(): boolean;
+    abstract is_some(): boolean;
+    abstract unwrap(): T;
+}
+declare class Some<T> extends Option<T> {
+    private _t;
+    constructor(_t: T);
+    is_none(): boolean;
+    is_some(): boolean;
+    unwrap(): T;
+}
+declare class None<T> extends Option<T> {
+    is_none(): boolean;
+    is_some(): boolean;
+    unwrap(): T;
+}
+type WithoutOption<T> = T extends Option<infer U> ? U : T;
+
+type TraceCtx = {
+    readonly spanId: string;
+    readonly time: Time;
+    readonly parent: TraceNode;
+    readonly metrics: Map<string, Metric<unknown>>;
+    readonly logger?: Logger;
+} & Record<string, unknown>;
+type CleanCtx = {
+    readonly spanId: string;
+} & Record<string, unknown>;
+type TraceCtxParam = {
+    readonly spanId: string;
+} & Partial<{
+    readonly time: Time;
+    readonly parent: TraceNode;
+    readonly logger: Logger;
+}> & Record<string, unknown>;
+declare class Metric<T> {
+    value?: T;
+    readonly path: string;
+    constructor(path: string);
+    set(value: T): void;
+    add<R extends number | ArrayLike<T>>(value: R): void;
+}
+type MetricMap = Map<string, Metric<unknown>>;
+declare class Metrics {
+    readonly tracenode: TraceNode;
+    private readonly map;
+    readonly spanRefs: MetricMap;
+    constructor(tracenode: TraceNode);
+    toJSON(): Record<string, unknown>;
+    get<T>(ipath: string): Metric<T>;
+}
+interface Invokaction {
+    readonly result: "success" | "error";
+    readonly start: number;
+    readonly end: number;
+    readonly metrics?: Metrics;
+}
+type TraceNodeMap = Map<string, TraceNode>;
+declare class TraceNode {
+    readonly childs: TraceNodeMap;
+    readonly invokations: Invokaction[];
+    readonly spanId: string;
+    readonly ctx: TraceCtx;
+    readonly metrics: Metrics;
+    static root(time: Time, logger?: Logger): TraceNode;
+    constructor(ctx: TraceCtx);
+    getRootPath(rpath?: string[]): string;
+    invokes(): {
+        ctx: CleanCtx;
+        invokations: Invokaction[];
+    };
+    ctxWith(spanId: string, logger?: Logger): TraceCtxParam;
+    span<V extends (trace: TraceNode) => Promise<T> | T, T>(inSpanId: string | TraceCtxParam, fn: V): ReturnType<V>;
+}
+
+interface ResolveSeqItem<T, C> {
+    readonly future: Future<T>;
+    readonly fn: (c: C) => Promise<T>;
+    readonly id?: number;
+}
+declare class ResolveSeq<T, C = void> {
+    readonly ctx: C;
+    constructor(ctx?: C);
+    reset(): void;
+    _step(item?: ResolveSeqItem<T, C> | undefined): Promise<void>;
+    readonly _seqFutures: ResolveSeqItem<T, C>[];
+    add(fn: (c: C) => Promise<T>, id?: number): Promise<T>;
+}
+declare class ResolveOnce<T, CTX = void> {
+    _onceDone: boolean;
+    readonly _onceFutures: Future<T>[];
+    _onceOk: boolean;
+    _onceValue?: T;
+    _onceError?: Error;
+    _isPromise: boolean;
+    readonly ctx: CTX;
+    constructor(ctx?: CTX);
+    get ready(): boolean;
+    reset(): void;
+    once<R>(fn: (c: CTX) => R): R;
+}
+declare class Keyed<T extends {
+    reset: () => void;
+}, K = string> {
+    private readonly _map;
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T);
+    asyncGet(key: () => Promise<K>): Promise<T>;
+    get(key: K | (() => K)): T;
+    unget(key: K): void;
+    reset(): void;
+}
+declare class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K> {
+    constructor();
+}
+declare class KeyedResolvSeq<T, K = string> extends Keyed<ResolveSeq<T, K>, K> {
+    constructor();
+}
+
+interface Runtime {
+    isNodeIsh: boolean;
+    isBrowser: boolean;
+    isDeno: boolean;
+    isReactNative: boolean;
+}
+declare function runtimeFn(): Runtime;
+
+interface CTJsonWebKey {
+    alg?: string;
+    crv?: string;
+    d?: string;
+    dp?: string;
+    dq?: string;
+    e?: string;
+    ext?: boolean;
+    k?: string;
+    key_ops?: string[];
+    kty?: string;
+    n?: string;
+    oth?: RsaOtherPrimesInfo[];
+    p?: string;
+    q?: string;
+    qi?: string;
+    use?: string;
+    x?: string;
+    y?: string;
+}
+type CTKeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
+type CTKeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
+interface CTAlgorithm {
+    name: string;
+}
+type CTAlgorithmIdentifier = CTAlgorithm | string;
+interface CTRsaHashedImportParams extends CTAlgorithm {
+    hash: CTAlgorithmIdentifier;
+}
+type CTNamedCurve = string;
+interface CTEcKeyImportParams extends CTAlgorithm {
+    namedCurve: CTNamedCurve;
+}
+interface CTHmacImportParams extends CTAlgorithm {
+    hash: CTAlgorithmIdentifier;
+    length?: number;
+}
+interface CTAesKeyAlgorithm extends CTAlgorithm {
+    length: number;
+}
+type CTKeyType = "private" | "public" | "secret";
+interface CTCryptoKey {
+    readonly algorithm: CTAlgorithm;
+    readonly extractable: boolean;
+    readonly type: CTKeyType;
+    readonly usages: CTKeyUsage[];
+}
+interface CTArrayBufferTypes {
+    ArrayBuffer: ArrayBuffer;
+}
+type CTArrayBufferLike = CTArrayBufferTypes[keyof CTArrayBufferTypes];
+interface CTArrayBufferView {
+    buffer: CTArrayBufferLike;
+    byteLength: number;
+    byteOffset: number;
+}
+type CTBufferSource = CTArrayBufferView | ArrayBuffer;
+interface CryptoRuntime {
+    importKey(format: CTKeyFormat, keyData: CTJsonWebKey | CTBufferSource, algorithm: CTAlgorithmIdentifier | CTRsaHashedImportParams | CTEcKeyImportParams | CTHmacImportParams | CTAesKeyAlgorithm, extractable: boolean, keyUsages: CTKeyUsage[]): Promise<CTCryptoKey>;
+    exportKey(format: CTKeyFormat, key: CTCryptoKey): Promise<CTJsonWebKey | ArrayBuffer>;
+    decrypt(algo: {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    }, key: CTCryptoKey, data: Uint8Array): Promise<ArrayBuffer>;
+    encrypt(algo: {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    }, key: CTCryptoKey, data: Uint8Array): Promise<ArrayBuffer>;
+    digestSHA256(data: Uint8Array): Promise<ArrayBuffer>;
+    randomBytes(size: number): Uint8Array;
+}
+declare function toCryptoRuntime(cryptoOpts?: Partial<CryptoRuntime>): CryptoRuntime;
+
+declare function bin2text(hex: ArrayBufferView, lineFn: (line: string) => void, size?: number): void;
+declare function bin2string(hex: ArrayBufferView, size?: number): string;
+
+declare const VERSION: string;
+
+export { type AsError, BuildURI, type CTAesKeyAlgorithm, type CTAlgorithm, type CTAlgorithmIdentifier, type CTArrayBufferView, type CTBufferSource, type CTCryptoKey, type CTEcKeyImportParams, type CTHmacImportParams, type CTJsonWebKey, type CTKeyFormat, type CTKeyType, type CTKeyUsage, type CTNamedCurve, type CTRsaHashedImportParams, type CleanCtx, type CoerceURI, type CryptoRuntime, type FnSerialized, Future, type Invokaction, IsLogger, JSONFormatter, Keyed, KeyedResolvOnce, KeyedResolvSeq, type Lengthed, Level, type LevelHandler, LevelHandlerImpl, LevelHandlerSingleton, LogCollector, type LogFormatter, type LogSerializable, LogValue, type LogValueArg, LogWriteStream, type Logger, LoggerImpl, type LoggerImplParams, type LoggerInterface, Metric, type MetricMap, Metrics, MockLogger, type MockLoggerReturn, MutableURL, None, Option, ResolveOnce, ResolveSeq, Result, ResultError, ResultOK, type Runtime, type Serialized, type SizeOrLength, type Sized, Some, SysAbstraction, Time, type TraceCtx, type TraceCtxParam, TraceNode, type TraceNodeMap, TxtEnDecoder, URI, VERSION, type WithLogger, type WithoutOption, type WithoutResult, YAMLFormatter, asyncLogValue, bin2string, bin2text, exception2Result, isURL, logValue, protocols, removeSelfRef, runtimeFn, toCryptoRuntime };