@tstdl/base 0.93.72 → 0.93.73

package/browser/pdf-options.d.ts

@@ -1,16 +1,18 @@
-export declare enum PdfFormat {
-    Letter = "letter",
-    Legal = "legal",
-    Tabloid = "tabloid",
-    Ledger = "ledger",
-    A0 = "a0",
-    A1 = "a1",
-    A2 = "a2",
-    A3 = "a3",
-    A4 = "a4",
-    A5 = "a5",
-    A6 = "a6"
-}
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const PdfFormat: {
+    readonly Letter: "letter";
+    readonly Legal: "legal";
+    readonly Tabloid: "tabloid";
+    readonly Ledger: "ledger";
+    readonly A0: "a0";
+    readonly A1: "a1";
+    readonly A2: "a2";
+    readonly A3: "a3";
+    readonly A4: "a4";
+    readonly A5: "a5";
+    readonly A6: "a6";
+};
+export type PdfFormat = EnumType<typeof PdfFormat>;
 export declare class PdfMarginObject {
     top?: number | string;
     bottom?: number | string;

package/browser/pdf-options.js

@@ -7,21 +7,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+import { defineEnum } from '../enumeration/enumeration.js';
 import { Enumeration, Optional, Union } from '../schema/index.js';
-export var PdfFormat;
-(function (PdfFormat) {
-    PdfFormat["Letter"] = "letter";
-    PdfFormat["Legal"] = "legal";
-    PdfFormat["Tabloid"] = "tabloid";
-    PdfFormat["Ledger"] = "ledger";
-    PdfFormat["A0"] = "a0";
-    PdfFormat["A1"] = "a1";
-    PdfFormat["A2"] = "a2";
-    PdfFormat["A3"] = "a3";
-    PdfFormat["A4"] = "a4";
-    PdfFormat["A5"] = "a5";
-    PdfFormat["A6"] = "a6";
-})(PdfFormat || (PdfFormat = {}));
+export const PdfFormat = defineEnum('PdfFormat', {
+    Letter: 'letter',
+    Legal: 'legal',
+    Tabloid: 'tabloid',
+    Ledger: 'ledger',
+    A0: 'a0',
+    A1: 'a1',
+    A2: 'a2',
+    A3: 'a3',
+    A4: 'a4',
+    A5: 'a5',
+    A6: 'a6',
+});
 export class PdfMarginObject {
     top;
     bottom;

package/collections/index.d.ts

@@ -4,7 +4,6 @@
  * @module Collections
  */
 export * from './collection.js';
-export * from './keyed-set.js';
 export * from './list.js';
 export * from './sorted-array-list.js';
 export * from './sorted-list.js';

package/collections/index.js

@@ -4,7 +4,6 @@
  * @module Collections
  */
 export * from './collection.js';
-export * from './keyed-set.js';
 export * from './list.js';
 export * from './sorted-array-list.js';
 export * from './sorted-list.js';

package/http/http.error.d.ts

@@ -1,19 +1,21 @@
+import { type EnumType } from '../enumeration/enumeration.js';
 import type { TypedOmit, UndefinableJson } from '../types/index.js';
 import type { ErrorExtraInfo } from '../utils/format-error.js';
 import { CustomError } from '../errors/custom.error.js';
 import type { HttpClientRequest, HttpClientRequestObject, HttpClientResponse, HttpClientResponseObject } from './client/index.js';
-export declare enum HttpErrorReason {
-    Unknown = "Unknown",
-    Cancelled = "Cancelled",
-    Network = "Network",
-    InvalidRequest = "InvalidRequest",
-    StatusCode = "StatusCode",
+export declare const HttpErrorReason: {
+    readonly Unknown: "Unknown";
+    readonly Cancelled: "Cancelled";
+    readonly Network: "Network";
+    readonly InvalidRequest: "InvalidRequest";
+    readonly StatusCode: "StatusCode";
     /** Valid http response containing an error */
-    ErrorResponse = "ErrorResponse",
+    readonly ErrorResponse: "ErrorResponse";
     /** Invalid http response */
-    ResponseError = "ResponseError",
-    Timeout = "Timeout"
-}
+    readonly ResponseError: "ResponseError";
+    readonly Timeout: "Timeout";
+};
+export type HttpErrorReason = EnumType<typeof HttpErrorReason>;
 export declare class HttpError extends CustomError implements ErrorExtraInfo {
     static readonly errorName = "HttpError";
     readonly reason: HttpErrorReason;

package/http/http.error.js

@@ -1,19 +1,19 @@
+import { defineEnum } from '../enumeration/enumeration.js';
 import { propertyNameOf } from '../utils/object/property-name.js';
 import { isDefined, isNotString, isString } from '../utils/type-guards.js';
 import { CustomError } from '../errors/custom.error.js';
-export var HttpErrorReason;
-(function (HttpErrorReason) {
-    HttpErrorReason["Unknown"] = "Unknown";
-    HttpErrorReason["Cancelled"] = "Cancelled";
-    HttpErrorReason["Network"] = "Network";
-    HttpErrorReason["InvalidRequest"] = "InvalidRequest";
-    HttpErrorReason["StatusCode"] = "StatusCode";
+export const HttpErrorReason = defineEnum('HttpErrorReason', {
+    Unknown: 'Unknown',
+    Cancelled: 'Cancelled',
+    Network: 'Network',
+    InvalidRequest: 'InvalidRequest',
+    StatusCode: 'StatusCode',
     /** Valid http response containing an error */
-    HttpErrorReason["ErrorResponse"] = "ErrorResponse";
+    ErrorResponse: 'ErrorResponse',
     /** Invalid http response */
-    HttpErrorReason["ResponseError"] = "ResponseError";
-    HttpErrorReason["Timeout"] = "Timeout";
-})(HttpErrorReason || (HttpErrorReason = {}));
+    ResponseError: 'ResponseError',
+    Timeout: 'Timeout',
+});
 export class HttpError extends CustomError {
     static errorName = 'HttpError';
     reason;

package/image-service/image-service.d.ts

@@ -1,26 +1,30 @@
-export declare enum ImageResizeMode {
-    Fit = "fit",
-    Fill = "fill"
-}
-export declare enum ImageFormat {
-    Png = "png",
-    Jpg = "jpg",
-    Jpeg = "jpeg",
-    Webp = "webp",
-    Avif = "avif"
-}
-export declare enum ImageOrigin {
-    Center = "center",
-    Smart = "smart",
-    Top = "top",
-    Left = "left",
-    Right = "right",
-    Bottom = "bottom",
-    TopLeft = "topleft",
-    TopRight = "topright",
-    BottomLeft = "bottomleft",
-    BottomRight = "bottomright"
-}
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const ImageResizeMode: {
+    readonly Fit: "fit";
+    readonly Fill: "fill";
+};
+export type ImageResizeMode = EnumType<typeof ImageResizeMode>;
+export declare const ImageFormat: {
+    readonly Png: "png";
+    readonly Jpg: "jpg";
+    readonly Jpeg: "jpeg";
+    readonly Webp: "webp";
+    readonly Avif: "avif";
+};
+export type ImageFormat = EnumType<typeof ImageFormat>;
+export declare const ImageOrigin: {
+    readonly Center: "center";
+    readonly Smart: "smart";
+    readonly Top: "top";
+    readonly Left: "left";
+    readonly Right: "right";
+    readonly Bottom: "bottom";
+    readonly TopLeft: "topleft";
+    readonly TopRight: "topright";
+    readonly BottomLeft: "bottomleft";
+    readonly BottomRight: "bottomright";
+};
+export type ImageOrigin = EnumType<typeof ImageOrigin>;
 export declare class ImageOptions {
     resizeMode?: ImageResizeMode;
     width?: number;

package/image-service/image-service.js

@@ -7,33 +7,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+import { defineEnum } from '../enumeration/enumeration.js';
 import { Enumeration, NumberProperty, Optional } from '../schema/index.js';
-export var ImageResizeMode;
-(function (ImageResizeMode) {
-    ImageResizeMode["Fit"] = "fit";
-    ImageResizeMode["Fill"] = "fill";
-})(ImageResizeMode || (ImageResizeMode = {}));
-export var ImageFormat;
-(function (ImageFormat) {
-    ImageFormat["Png"] = "png";
-    ImageFormat["Jpg"] = "jpg";
-    ImageFormat["Jpeg"] = "jpeg";
-    ImageFormat["Webp"] = "webp";
-    ImageFormat["Avif"] = "avif";
-})(ImageFormat || (ImageFormat = {}));
-export var ImageOrigin;
-(function (ImageOrigin) {
-    ImageOrigin["Center"] = "center";
-    ImageOrigin["Smart"] = "smart";
-    ImageOrigin["Top"] = "top";
-    ImageOrigin["Left"] = "left";
-    ImageOrigin["Right"] = "right";
-    ImageOrigin["Bottom"] = "bottom";
-    ImageOrigin["TopLeft"] = "topleft";
-    ImageOrigin["TopRight"] = "topright";
-    ImageOrigin["BottomLeft"] = "bottomleft";
-    ImageOrigin["BottomRight"] = "bottomright";
-})(ImageOrigin || (ImageOrigin = {}));
+export const ImageResizeMode = defineEnum('ImageResizeMode', {
+    Fit: 'fit',
+    Fill: 'fill',
+});
+export const ImageFormat = defineEnum('ImageFormat', {
+    Png: 'png',
+    Jpg: 'jpg',
+    Jpeg: 'jpeg',
+    Webp: 'webp',
+    Avif: 'avif',
+});
+export const ImageOrigin = defineEnum('ImageOrigin', {
+    Center: 'center',
+    Smart: 'smart',
+    Top: 'top',
+    Left: 'left',
+    Right: 'right',
+    Bottom: 'bottom',
+    TopLeft: 'topleft',
+    TopRight: 'topright',
+    BottomLeft: 'bottomleft',
+    BottomRight: 'bottomright',
+});
 export class ImageOptions {
     resizeMode;
     width;

package/package.json

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

package/promise/deferred-promise.d.ts

@@ -1,9 +1,11 @@
+import { type EnumType } from '../enumeration/enumeration.js';
 import type { PromiseExecutor } from './types.js';
-export declare const enum PromiseState {
-    Pending = 0,
-    Resolved = 1,
-    Rejected = 2
-}
+export declare const PromiseState: {
+    readonly Pending: 0;
+    readonly Resolved: 1;
+    readonly Rejected: 2;
+};
+export type PromiseState = EnumType<typeof PromiseState>;
 export declare class DeferredPromise<T = void> extends Promise<T> {
     private backingPromise;
     private resolvePromise;

package/promise/deferred-promise.js

@@ -1,9 +1,9 @@
-export var PromiseState;
-(function (PromiseState) {
-    PromiseState[PromiseState["Pending"] = 0] = "Pending";
-    PromiseState[PromiseState["Resolved"] = 1] = "Resolved";
-    PromiseState[PromiseState["Rejected"] = 2] = "Rejected";
-})(PromiseState || (PromiseState = {}));
+import { defineEnum } from '../enumeration/enumeration.js';
+export const PromiseState = defineEnum('PromiseState', {
+    Pending: 0,
+    Resolved: 1,
+    Rejected: 2,
+});
 export class DeferredPromise extends Promise {
     backingPromise;
     resolvePromise;

package/signals/implementation/to-signal.js

@@ -3,6 +3,7 @@ import { registerFinalization } from '../../memory/finalization.js';
 import { assertNotInReactiveContext } from './asserts.js';
 import { computed } from './computed.js';
 import { signal } from './writable-signal.js';
+import { defineEnum } from '../../enumeration/enumeration.js';
 /**
  * Get the current value of an `Observable` as a reactive `Signal`.
  *
@@ -72,9 +73,8 @@ export function toSignal(source, options) {
 function makeToSignalEqual(userEquality = Object.is) {
     return (a, b) => a.kind === StateKind.Value && b.kind === StateKind.Value && userEquality(a.value, b.value);
 }
-var StateKind;
-(function (StateKind) {
-    StateKind[StateKind["NoValue"] = 0] = "NoValue";
-    StateKind[StateKind["Value"] = 1] = "Value";
-    StateKind[StateKind["Error"] = 2] = "Error";
-})(StateKind || (StateKind = {}));
+const StateKind = defineEnum('StateKind', {
+    NoValue: 0,
+    Value: 1,
+    Error: 2,
+});

package/sse/server-sent-events.d.ts

@@ -1,21 +1,17 @@
+import { type EnumType } from '../enumeration/enumeration.js';
 import { type Observable } from 'rxjs';
 /**
  * Represents the possible states of a Server-Sent Events connection.
  */
-export declare enum ServerSentEventsState {
-    /**
-     * The connection is currently being established.
-     */
-    Connecting = 0,
-    /**
-     * The connection is open and ready to receive events.
-     */
-    Open = 1,
-    /**
-     * The connection is closed.
-     */
-    Closed = 2
-}
+export declare const ServerSentEventsState: {
+    /** The connection is currently being established. */
+    readonly Connecting: 0;
+    /** The connection is open and ready to receive events. */
+    readonly Open: 1;
+    /** The connection is closed. */
+    readonly Closed: 2;
+};
+export type ServerSentEventsState = EnumType<typeof ServerSentEventsState>;
 /**
  * A wrapper around the EventSource API, providing an RxJS-friendly interface for Server-Sent Events.
  */

package/sse/server-sent-events.js

@@ -1,23 +1,17 @@
+import { defineEnum } from '../enumeration/enumeration.js';
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { ReplaySubject, distinctUntilChanged, filter, fromEvent, map, merge, share, shareReplay, startWith, takeUntil } from 'rxjs';
 /**
  * Represents the possible states of a Server-Sent Events connection.
  */
-export var ServerSentEventsState;
-(function (ServerSentEventsState) {
-    /**
-     * The connection is currently being established.
-     */
-    ServerSentEventsState[ServerSentEventsState["Connecting"] = 0] = "Connecting";
-    /**
-     * The connection is open and ready to receive events.
-     */
-    ServerSentEventsState[ServerSentEventsState["Open"] = 1] = "Open";
-    /**
-     * The connection is closed.
-     */
-    ServerSentEventsState[ServerSentEventsState["Closed"] = 2] = "Closed";
-})(ServerSentEventsState || (ServerSentEventsState = {}));
+export const ServerSentEventsState = defineEnum('ServerSentEventsState', {
+    /** The connection is currently being established. */
+    Connecting: 0,
+    /** The connection is open and ready to receive events. */
+    Open: 1,
+    /** The connection is closed. */
+    Closed: 2,
+});
 /**
  * A wrapper around the EventSource API, providing an RxJS-friendly interface for Server-Sent Events.
  */

package/utils/alphabet.d.ts

@@ -1,12 +1,14 @@
-export declare enum Alphabet {
-    LowerCase = "abcdefghijklmnopqrstuvwxyz",
-    UpperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
-    Numbers = "0123456789",
-    LowerUpperCase = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-    LowerCaseNumbers = "abcdefghijklmnopqrstuvwxyz0123456789",
-    UpperCaseNumbers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
-    LowerUpperCaseNumbers = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
-    ZBase32 = "ybndrfg8ejkmcpqxot1uwisza345h769",
-    LowerCaseHex = "0123456789abcdef",
-    UpperCaseHex = "0123456789ABCDEF"
-}
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const Alphabet: {
+    readonly LowerCase: "abcdefghijklmnopqrstuvwxyz";
+    readonly UpperCase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    readonly Numbers: "0123456789";
+    readonly LowerUpperCase: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    readonly LowerCaseNumbers: "abcdefghijklmnopqrstuvwxyz0123456789";
+    readonly UpperCaseNumbers: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    readonly LowerUpperCaseNumbers: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    readonly ZBase32: "ybndrfg8ejkmcpqxot1uwisza345h769";
+    readonly LowerCaseHex: "0123456789abcdef";
+    readonly UpperCaseHex: "0123456789ABCDEF";
+};
+export type Alphabet = EnumType<typeof Alphabet>;

package/utils/alphabet.js

@@ -1,13 +1,13 @@
-export var Alphabet;
-(function (Alphabet) {
-    Alphabet["LowerCase"] = "abcdefghijklmnopqrstuvwxyz";
-    Alphabet["UpperCase"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    Alphabet["Numbers"] = "0123456789";
-    Alphabet["LowerUpperCase"] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    Alphabet["LowerCaseNumbers"] = "abcdefghijklmnopqrstuvwxyz0123456789";
-    Alphabet["UpperCaseNumbers"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    Alphabet["LowerUpperCaseNumbers"] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    Alphabet["ZBase32"] = "ybndrfg8ejkmcpqxot1uwisza345h769";
-    Alphabet["LowerCaseHex"] = "0123456789abcdef";
-    Alphabet["UpperCaseHex"] = "0123456789ABCDEF";
-})(Alphabet || (Alphabet = {}));
+import { defineEnum } from '../enumeration/enumeration.js';
+export const Alphabet = defineEnum('Alphabet', {
+    LowerCase: 'abcdefghijklmnopqrstuvwxyz',
+    UpperCase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    Numbers: '0123456789',
+    LowerUpperCase: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    LowerCaseNumbers: 'abcdefghijklmnopqrstuvwxyz0123456789',
+    UpperCaseNumbers: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
+    LowerUpperCaseNumbers: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
+    ZBase32: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+    LowerCaseHex: '0123456789abcdef',
+    UpperCaseHex: '0123456789ABCDEF',
+});

package/utils/binary-search.d.ts

@@ -1,3 +1,4 @@
+import { type EnumType } from '../enumeration/enumeration.js';
 import type { Comparator } from './sort.js';
 export type BinarySearchOptions = {
     /** minimum index to search at */
@@ -5,6 +6,12 @@ export type BinarySearchOptions = {
     /** maximum index to search at */
     max?: number;
 };
+export declare const Position: {
+    readonly Undefined: 0;
+    readonly First: 1;
+    readonly Last: 2;
+};
+export type Position = EnumType<typeof Position>;
 export declare function binarySearch<T extends TComparator, TComparator>(values: ArrayLike<T>, searchValue: TComparator, comparator?: Comparator<TComparator>, options?: BinarySearchOptions): number | undefined;
 export declare function binarySearchFirst<T extends TComparator, TComparator>(values: ArrayLike<T>, searchValue: TComparator, comparator?: Comparator<TComparator>, options?: BinarySearchOptions): number | undefined;
 export declare function binarySearchLast<T extends TComparator, TComparator>(values: ArrayLike<T>, searchValue: TComparator, comparator?: Comparator<TComparator>, options?: BinarySearchOptions): number | undefined;

package/utils/binary-search.js

@@ -1,10 +1,10 @@
+import { defineEnum } from '../enumeration/enumeration.js';
 import { compareByValue } from './comparison.js';
-var Position;
-(function (Position) {
-    Position[Position["Undefined"] = 0] = "Undefined";
-    Position[Position["First"] = 1] = "First";
-    Position[Position["Last"] = 2] = "Last";
-})(Position || (Position = {}));
+export const Position = defineEnum('Position', {
+    Undefined: 0,
+    First: 1,
+    Last: 2,
+});
 export function binarySearch(values, searchValue, comparator = compareByValue, options) {
     return _binarySearch(values, searchValue, Position.Undefined, comparator, options);
 }

package/utils/index.d.ts

@@ -16,7 +16,6 @@ export * from './date-time.js';
 export * from './encoding.js';
 export * from './enum.js';
 export * from './equals.js';
-export * from './event-loop.js';
 export * from './factory-map.js';
 export * from './feedable-async-iterable.js';
 export * from './file-reader.js';
@@ -35,8 +34,6 @@ export * from './noop.js';
 export * from './ordered-feedable-async-iterable.js';
 export * from './patch-worker.js';
 export * from './patterns.js';
-export * from './periodic-reporter.js';
-export * from './periodic-sampler.js';
 export * from './provider-function-iterable.js';
 export * from './proxy.js';
 export * from './random.js';

package/utils/index.js

@@ -16,7 +16,6 @@ export * from './date-time.js';
 export * from './encoding.js';
 export * from './enum.js';
 export * from './equals.js';
-export * from './event-loop.js';
 export * from './factory-map.js';
 export * from './feedable-async-iterable.js';
 export * from './file-reader.js';
@@ -35,8 +34,6 @@ export * from './noop.js';
 export * from './ordered-feedable-async-iterable.js';
 export * from './patch-worker.js';
 export * from './patterns.js';
-export * from './periodic-reporter.js';
-export * from './periodic-sampler.js';
 export * from './provider-function-iterable.js';
 export * from './proxy.js';
 export * from './random.js';

package/utils/moving-metric.d.ts

@@ -1,15 +1,17 @@
-export declare enum MetricAggregation {
-    Sum = 0,
-    Mean = 1,
-    Median = 2,
-    Minimum = 3,
-    Maximum = 4,
-    Count = 5,
-    Quantile = 6,
-    Rate = 7,
-    RateBySum = 8
-}
-export type MetricAggregationOptions<T extends MetricAggregation> = T extends MetricAggregation.Quantile ? {
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const MetricAggregation: {
+    readonly Sum: "sum";
+    readonly Mean: "mean";
+    readonly Median: "median";
+    readonly Minimum: "minimum";
+    readonly Maximum: "maximum";
+    readonly Count: "count";
+    readonly Quantile: "quantile";
+    readonly Rate: "rate";
+    readonly RateBySum: "rate-by-sum";
+};
+export type MetricAggregation = EnumType<typeof MetricAggregation>;
+export type MetricAggregationOptions<T extends MetricAggregation> = T extends (typeof MetricAggregation)['Quantile'] ? {
     scalar: number;
 } : never;
 export declare class MovingMetric {

package/utils/moving-metric.js

@@ -1,16 +1,16 @@
+import { defineEnum } from '../enumeration/enumeration.js';
 import { Timer } from './timer.js';
-export var MetricAggregation;
-(function (MetricAggregation) {
-    MetricAggregation[MetricAggregation["Sum"] = 0] = "Sum";
-    MetricAggregation[MetricAggregation["Mean"] = 1] = "Mean";
-    MetricAggregation[MetricAggregation["Median"] = 2] = "Median";
-    MetricAggregation[MetricAggregation["Minimum"] = 3] = "Minimum";
-    MetricAggregation[MetricAggregation["Maximum"] = 4] = "Maximum";
-    MetricAggregation[MetricAggregation["Count"] = 5] = "Count";
-    MetricAggregation[MetricAggregation["Quantile"] = 6] = "Quantile";
-    MetricAggregation[MetricAggregation["Rate"] = 7] = "Rate";
-    MetricAggregation[MetricAggregation["RateBySum"] = 8] = "RateBySum";
-})(MetricAggregation || (MetricAggregation = {}));
+export const MetricAggregation = defineEnum('MetricAggregation', {
+    Sum: 'sum',
+    Mean: 'mean',
+    Median: 'median',
+    Minimum: 'minimum',
+    Maximum: 'maximum',
+    Count: 'count',
+    Quantile: 'quantile',
+    Rate: 'rate',
+    RateBySum: 'rate-by-sum',
+});
 export class MovingMetric {
     interval;
     samples;

package/utils/url-builder.d.ts

@@ -1,4 +1,10 @@
+import { type EnumType } from '../enumeration/index.js';
 import type { UndefinableJsonObject, UndefinableJsonPrimitive } from '../types/index.js';
+export declare const UrlBuilderPartType: {
+    readonly Literal: 0;
+    readonly Parameter: 1;
+};
+export type UrlBuilderPartType = EnumType<typeof UrlBuilderPartType>;
 export type UrlBuilderParameterValue = UndefinableJsonPrimitive;
 export type UrlBuilderParameters = UndefinableJsonObject;
 export type UrlBuilderOptions = {

package/utils/url-builder.js

@@ -1,11 +1,11 @@
+import { defineEnum } from '../enumeration/index.js';
 import { normalizeSingleHttpValue } from '../http/types.js';
 import { memoizeSingle } from './function/memoize.js';
 import { isArray, isDefined, isObject, isUndefined } from './type-guards.js';
-var UrlBuilderPartType;
-(function (UrlBuilderPartType) {
-    UrlBuilderPartType[UrlBuilderPartType["Literal"] = 0] = "Literal";
-    UrlBuilderPartType[UrlBuilderPartType["Parameter"] = 1] = "Parameter";
-})(UrlBuilderPartType || (UrlBuilderPartType = {}));
+export const UrlBuilderPartType = defineEnum('UrlBuilderPartType', {
+    Literal: 0,
+    Parameter: 1,
+});
 const urlParseRegex = /(?<literal>[^:]+|:\/+|:\d[^:]+)|:(?<parameter>[\w-]+)/ug;
 export function compileUrlBuilder(url) {
     const parts = [];

package/collections/keyed-set.d.ts

@@ -1,29 +0,0 @@
-export declare enum KeyedSetMode {
-    Keep = 0,
-    Overwrite = 1
-}
-export type Selector<T> = (value: T) => any;
-export declare class KeyedSet<T> implements Set<T> {
-    private readonly selector;
-    private readonly mode;
-    private readonly backingMap;
-    readonly [Symbol.toStringTag]: 'KeyedSet';
-    constructor(selector: Selector<T>, mode?: KeyedSetMode);
-    get size(): number;
-    add(value: T): this;
-    clear(): void;
-    delete(value: T): boolean;
-    union<U>(_other: ReadonlySetLike<U>): Set<T | U>;
-    intersection<U>(_other: ReadonlySetLike<U>): Set<T & U>;
-    difference<U>(_other: ReadonlySetLike<U>): Set<T>;
-    symmetricDifference<U>(_other: ReadonlySetLike<U>): Set<T | U>;
-    isSubsetOf(_other: ReadonlySetLike<unknown>): boolean;
-    isSupersetOf(_other: ReadonlySetLike<unknown>): boolean;
-    isDisjointFrom(_other: ReadonlySetLike<unknown>): boolean;
-    forEach(callback: (value: T, value2: T, set: KeyedSet<T>) => void, thisArg?: any): void;
-    has(value: T): boolean;
-    [Symbol.iterator](): SetIterator<T>;
-    entries(): SetIterator<[T, T]>;
-    keys(): SetIterator<T>;
-    values(): SetIterator<T>;
-}

package/collections/keyed-set.js

@@ -1,78 +0,0 @@
-import { NotSupportedError } from '../errors/not-supported.error.js';
-import { map } from '../utils/iterable-helpers/map.js';
-export var KeyedSetMode;
-(function (KeyedSetMode) {
-    KeyedSetMode[KeyedSetMode["Keep"] = 0] = "Keep";
-    KeyedSetMode[KeyedSetMode["Overwrite"] = 1] = "Overwrite";
-})(KeyedSetMode || (KeyedSetMode = {}));
-export class KeyedSet {
-    selector;
-    mode;
-    backingMap;
-    [Symbol.toStringTag];
-    constructor(selector, mode = KeyedSetMode.Overwrite) {
-        this.selector = selector;
-        this.mode = mode;
-        this[Symbol.toStringTag] = 'KeyedSet';
-        this.backingMap = new Map();
-    }
-    get size() {
-        return this.backingMap.size;
-    }
-    add(value) {
-        const key = this.selector(value);
-        if (this.mode == KeyedSetMode.Keep && this.backingMap.has(key)) {
-            return this;
-        }
-        this.backingMap.set(key, value);
-        return this;
-    }
-    clear() {
-        this.backingMap.clear();
-    }
-    delete(value) {
-        const key = this.selector(value);
-        return this.backingMap.delete(key);
-    }
-    union(_other) {
-        throw new NotSupportedError();
-    }
-    intersection(_other) {
-        throw new NotSupportedError();
-    }
-    difference(_other) {
-        throw new NotSupportedError();
-    }
-    symmetricDifference(_other) {
-        throw new NotSupportedError();
-    }
-    isSubsetOf(_other) {
-        throw new NotSupportedError();
-    }
-    isSupersetOf(_other) {
-        throw new NotSupportedError();
-    }
-    isDisjointFrom(_other) {
-        throw new NotSupportedError();
-    }
-    forEach(callback, thisArg) {
-        const boundCallback = callback.bind(thisArg);
-        this.backingMap.forEach((value) => boundCallback(value, value, this));
-    }
-    has(value) {
-        const key = this.selector(value);
-        return this.backingMap.has(key);
-    }
-    [Symbol.iterator]() {
-        return this.backingMap.values();
-    }
-    *entries() {
-        yield* map(this.backingMap.values(), (value) => [value, value]);
-    }
-    keys() {
-        return this.backingMap.values();
-    }
-    values() {
-        return this.backingMap.values();
-    }
-}

package/utils/event-loop.d.ts

@@ -1,4 +0,0 @@
-import type { CancellationSignal } from '../cancellation/token.js';
-import type { Logger } from '../logger/index.js';
-export declare function measureEventLoopDelay(): Promise<number>;
-export declare function runEventLoopWatcher(logger: Logger, cancellationSignal: CancellationSignal): void;

package/utils/event-loop.js

@@ -1,21 +0,0 @@
-import { formatDuration } from './format.js';
-import { AggregationMode, PeriodicSampler } from './periodic-sampler.js';
-import { Timer } from './timer.js';
-export async function measureEventLoopDelay() {
-    return new Promise((resolve) => {
-        const stopwatch = new Timer();
-        setImmediate(() => {
-            stopwatch.start();
-            // inner setImmediate, to measure an full event-loop-cycle
-            setImmediate(() => resolve(stopwatch.milliseconds));
-        });
-    });
-}
-export function runEventLoopWatcher(logger, cancellationSignal) {
-    const sampler = new PeriodicSampler(measureEventLoopDelay, 50);
-    sampler
-        .watch(0, 100, AggregationMode.ThirdQuartile)
-        .subscribe((delay) => logger.debug(`eventloop: ${formatDuration(delay, 2)}`));
-    sampler.start();
-    void cancellationSignal.then(async () => sampler.stop());
-}

package/utils/periodic-reporter.d.ts

@@ -1,18 +0,0 @@
-import { type Observable } from 'rxjs';
-export declare class PeriodicReporter {
-    private readonly reportSubject;
-    private readonly interval;
-    private readonly ignoreZero;
-    private readonly resetAfterReport;
-    private readonly stopToken;
-    private readonly stopped;
-    private running;
-    private counter;
-    private stopRequested;
-    get report(): Observable<number>;
-    constructor(interval: number, ignoreZero: boolean, resetAfterReport: boolean);
-    increase(count: number): void;
-    run(): void;
-    stop(): Promise<void>;
-    private emitReport;
-}

package/utils/periodic-reporter.js

@@ -1,64 +0,0 @@
-import { Subject } from 'rxjs';
-import { CancellationToken } from '../cancellation/token.js';
-import { DeferredPromise } from '../promise/deferred-promise.js';
-import { cancelableTimeout } from './timing.js';
-export class PeriodicReporter {
-    reportSubject;
-    interval;
-    ignoreZero;
-    resetAfterReport;
-    stopToken;
-    stopped;
-    running;
-    counter;
-    stopRequested;
-    get report() {
-        return this.reportSubject.asObservable();
-    }
-    constructor(interval, ignoreZero, resetAfterReport) {
-        this.interval = interval;
-        this.ignoreZero = ignoreZero;
-        this.resetAfterReport = resetAfterReport;
-        this.running = false;
-        this.stopToken = new CancellationToken();
-        this.stopped = new DeferredPromise();
-        this.reportSubject = new Subject();
-    }
-    increase(count) {
-        this.counter += count;
-    }
-    run() {
-        if (this.running) {
-            throw new Error('already started');
-        }
-        this.running = true;
-        void (async () => {
-            this.counter = 0;
-            this.stopRequested = false;
-            this.stopToken.unset();
-            this.stopped.reset();
-            while (!this.stopRequested) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                await cancelableTimeout(this.interval, this.stopToken);
-                if (!this.stopRequested && (!this.ignoreZero || (this.counter > 0))) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                    this.emitReport(this.resetAfterReport);
-                }
-            }
-            this.running = false;
-            this.stopped.resolve();
-        })();
-    }
-    async stop() {
-        if (!this.running) {
-            return;
-        }
-        this.stopRequested = true;
-        this.stopToken.set();
-        await this.stopped;
-    }
-    emitReport(resetAfterReport) {
-        this.reportSubject.next(this.counter);
-        if (resetAfterReport) {
-            this.counter = 0;
-        }
-    }
-}

package/utils/periodic-sampler.d.ts

@@ -1,22 +0,0 @@
-import { type Observable } from 'rxjs';
-export declare enum AggregationMode {
-    Minimum = 0,
-    Maximum = 1,
-    Mean = 2,
-    Median = 3,
-    FirstQuartile = 4,
-    ThirdQuartile = 5
-}
-export type SampleFunction = () => number | Promise<number>;
-export declare class PeriodicSampler {
-    private readonly sampleFunction;
-    private readonly subject;
-    private run;
-    private stopped;
-    sampleInterval: number;
-    constructor(sampleFunction: SampleFunction, sampleInterval?: number);
-    start(): void;
-    stop(): Promise<void>;
-    watch(threshold?: number, samples?: number, aggregation?: AggregationMode): Observable<number>;
-    private runSampleLoop;
-}

package/utils/periodic-sampler.js

@@ -1,75 +0,0 @@
-import { Subject, bufferCount, filter, map } from 'rxjs';
-import { compareByValue } from './comparison.js';
-import { average } from './math.js';
-import { timeout } from './timing.js';
-export var AggregationMode;
-(function (AggregationMode) {
-    AggregationMode[AggregationMode["Minimum"] = 0] = "Minimum";
-    AggregationMode[AggregationMode["Maximum"] = 1] = "Maximum";
-    AggregationMode[AggregationMode["Mean"] = 2] = "Mean";
-    AggregationMode[AggregationMode["Median"] = 3] = "Median";
-    AggregationMode[AggregationMode["FirstQuartile"] = 4] = "FirstQuartile";
-    AggregationMode[AggregationMode["ThirdQuartile"] = 5] = "ThirdQuartile";
-})(AggregationMode || (AggregationMode = {}));
-export class PeriodicSampler {
-    sampleFunction;
-    subject;
-    run;
-    stopped;
-    sampleInterval;
-    constructor(sampleFunction, sampleInterval = 100) {
-        this.sampleFunction = sampleFunction;
-        this.sampleInterval = sampleInterval;
-        this.run = false;
-        this.subject = new Subject();
-    }
-    start() {
-        if (this.run) {
-            throw new Error('already started');
-        }
-        this.run = true;
-        this.stopped = this.runSampleLoop();
-    }
-    async stop() {
-        this.run = false;
-        await this.stopped;
-    }
-    watch(threshold = 0, samples = 1, aggregation = AggregationMode.Maximum) {
-        const observable = this.subject.pipe(bufferCount(samples), map((measures) => aggregate(aggregation, measures)), filter((ms) => ms >= threshold));
-        return observable;
-    }
-    async runSampleLoop() {
-        while (this.run) {
-            const delay = await this.sampleFunction();
-            this.subject.next(delay);
-            await timeout(this.sampleInterval);
-        }
-    }
-}
-function aggregate(aggregation, values) {
-    switch (aggregation) {
-        case AggregationMode.Minimum:
-            return Math.min(...values);
-        case AggregationMode.Maximum:
-            return Math.max(...values);
-        case AggregationMode.Mean:
-            return average(values);
-        case AggregationMode.Median: {
-            values.sort(compareByValue);
-            const median = Math.floor(values.length / 2);
-            return values[median];
-        }
-        case AggregationMode.FirstQuartile: {
-            values.sort(compareByValue);
-            const firstQuartile = Math.floor(values.length / 4 * 1);
-            return values[firstQuartile];
-        }
-        case AggregationMode.ThirdQuartile: {
-            values.sort(compareByValue);
-            const thirdQuartile = Math.floor(values.length / 4 * 3);
-            return values[thirdQuartile];
-        }
-        default:
-            throw new Error(`aggregation mode ${aggregation} not implemented`);
-    }
-}