@esposter/shared 2.22.0 → 2.23.0

package/dist/index.d.ts

@@ -70,16 +70,22 @@ declare const RoutePath: {
 };
 type RoutePath = typeof RoutePath;
 //#endregion
-//#region src/util/types/GetProperties.d.ts
-type GetProperties<T, P extends string = "", D extends unknown[] = [unknown, unknown, unknown, unknown, unknown], R extends boolean = true> = [T] extends [never] ? never : D extends [] ? never : NonNullable<T> extends infer O ? O extends unknown[] ? GetArrayProps<O, P, D, R> : O extends object ? GetObjectProps<O, P, D, R> : GetPrimitiveProps<O, P, D, R> : never;
+//#region src/util/types/GetArrayProps.d.ts
 type GetArrayProps<T extends unknown[], P extends string, D extends unknown[], R extends boolean> = (D extends [unknown, ...infer Rest] ? GetProperties<T[number], R extends true ? `${P}[number]` : `${P}.[number]`, Rest, false> : never) | {
   path: R extends true ? "length" : `${P}.length`;
   value: T["length"];
 };
+//#endregion
+//#region src/util/types/KnownKeys.d.ts
+type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+//#endregion
+//#region src/util/types/GetObjectProps.d.ts
 type GetObjectProps<T, P extends string, D extends unknown[], R extends boolean> = { [K in keyof KnownKeys<T> & (number | string)]: K extends `${number}` ? never : NonNullable<T[K]> extends Function ? never : (D extends [unknown, ...infer Rest] ? GetProperties<T[K], R extends true ? `${K}` : `${P}.${K}`, Rest, false> : never) | {
   path: R extends true ? `${K}` : `${P}.${K}`;
   value: T[K];
 } }[keyof KnownKeys<T> & (number | string)];
+//#endregion
+//#region src/util/types/GetPrimitiveProps.d.ts
 type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boolean> = T extends string ? {
   path: R extends true ? "length" : `${P}.length`;
   value: number;
@@ -87,7 +93,9 @@ type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boole
   path: R extends true ? "description" : `${P}.description`;
   value: string | undefined;
 } : never;
-type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+//#endregion
+//#region src/util/types/GetProperties.d.ts
+type GetProperties<T, P extends string = "", D extends unknown[] = [unknown, unknown, unknown, unknown, unknown], R extends boolean = true> = [T] extends [never] ? never : D extends [] ? never : NonNullable<T> extends infer O ? O extends unknown[] ? GetArrayProps<O, P, D, R> : O extends object ? GetObjectProps<O, P, D, R> : GetPrimitiveProps<O, P, D, R> : never;
 //#endregion
 //#region src/util/types/GetPaths.d.ts
 type GetPaths<T> = GetProperties<T> extends infer U ? (U extends {
@@ -1689,6 +1697,33 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
 type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 //#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/promisable.d.ts
+/**
+Create a type that represents either the value or the value wrapped in `PromiseLike`.
+
+Use-cases:
+- A function accepts a callback that may either return a value synchronously or may return a promised value.
+- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+import type {Promisable} from 'type-fest';
+
+async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
+	const entry = await getLogEntry();
+	console.log(entry);
+}
+
+await logger(() => 'foo');
+await logger(() => Promise.resolve('bar'));
+```
+
+@category Async
+*/
+type Promisable<T> = T | PromiseLike<T>;
+//#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-lowercase.d.ts
 /**
 Returns a boolean for whether the given string literal is lowercase.
@@ -2042,6 +2077,318 @@ interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
 //#region src/services/app/constants.d.ts
 declare const SITE_NAME = "Esposter";
 //#endregion
+//#region ../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.d.ts
+interface ErrorConfig {
+  withStackTrace: boolean;
+}
+declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+  private _promise;
+  constructor(res: Promise<Result<T, E>>);
+  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+  static fromThrowable<A extends readonly any[], R, E>(fn: (...args: A) => Promise<R>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<R, E>;
+  static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
+  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
+  static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>;
+  andThrough<F>(f: (t: T) => Result<unknown, F> | ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+  andTee(f: (t: T) => unknown): ResultAsync<T, E>;
+  orTee(f: (t: E) => unknown): ResultAsync<T, E>;
+  mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>;
+  andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+  andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+  orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B>;
+  unwrapOr<A>(t: A): Promise<T | A>;
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap(): AsyncGenerator<Err<never, E>, T>;
+  then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+  [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
+}
+declare type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+declare type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
+declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Ok<L, R>[] : never : never : never;
+declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
+declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
+declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
+declare type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never };
+declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never };
+declare type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never };
+declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never };
+declare type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
+declare type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
+declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
+declare type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
+declare namespace Result {
+  /**
+   * Wraps a function with a try catch, creating a new function with the same
+   * arguments but returning `Ok` if successful, `Err` if the function throws
+   *
+   * @param fn function to wrap with ok on success or err on failure
+   * @param errorFn when an error is thrown, this will wrap the error result if provided
+   */
+  function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+  function combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
+  function combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResults<T>;
+  function combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+  function combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+}
+declare type Result<T, E> = Ok<T, E> | Err<T, E>;
+interface IResult<T, E> {
+  /**
+   * Used to check if a `Result` is an `OK`
+   *
+   * @returns `true` if the result is an `OK` variant of Result
+   */
+  isOk(): this is Ok<T, E>;
+  /**
+   * Used to check if a `Result` is an `Err`
+   *
+   * @returns `true` if the result is an `Err` variant of Result
+   */
+  isErr(): this is Err<T, E>;
+  /**
+   * Maps a `Result<T, E>` to `Result<U, E>`
+   * by applying a function to a contained `Ok` value, leaving an `Err` value
+   * untouched.
+   *
+   * @param f The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  map<A>(f: (t: T) => A): Result<A, E>;
+  /**
+   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+   * contained `Err` value, leaving an `Ok` value untouched.
+   *
+   * This function can be used to pass through a successful result while
+   * handling an error.
+   *
+   * @param f a function to apply to the error `Err` value
+   */
+  mapErr<U>(f: (e: E) => U): Result<T, U>;
+  /**
+   * Similar to `map` Except you must return a new `Result`.
+   *
+   * This is useful for when you need to do a subsequent computation using the
+   * inner `T` value, but that computation might fail.
+   * Additionally, `andThen` is really useful as a tool to flatten a
+   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
+   *
+   * @param f The function to apply to the current value
+   */
+  andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+  /**
+   * This "tee"s the current value to an passed-in computation such as side
+   * effect functions but still returns the same current value as the result.
+   *
+   * This is useful when you want to pass the current result to your side-track
+   * work such as logging but want to continue main-track work after that.
+   * This method does not care about the result of the passed in computation.
+   *
+   * @param f The function to apply to the current value
+   */
+  andTee(f: (t: T) => unknown): Result<T, E>;
+  /**
+   * This "tee"s the current `Err` value to an passed-in computation such as side
+   * effect functions but still returns the same `Err` value as the result.
+   *
+   * This is useful when you want to pass the current `Err` value to your side-track
+   * work such as logging but want to continue error-track work after that.
+   * This method does not care about the result of the passed in computation.
+   *
+   * @param f The function to apply to the current `Err` value
+   */
+  orTee(f: (t: E) => unknown): Result<T, E>;
+  /**
+   * Similar to `andTee` except error result of the computation will be passed
+   * to the downstream in case of an error.
+   *
+   * This version is useful when you want to make side-effects but in case of an
+   * error, you want to pass the error to the downstream.
+   *
+   * @param f The function to apply to the current value
+   */
+  andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
+  andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+  /**
+   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
+   *
+   * This is useful for error recovery.
+   *
+   *
+   * @param f  A function to apply to an `Err` value, leaving `Ok` values
+   * untouched.
+   */
+  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
+  /**
+   * Similar to `map` Except you must return a new `Result`.
+   *
+   * This is useful for when you need to do a subsequent async computation using
+   * the inner `T` value, but that computation might fail. Must return a ResultAsync
+   *
+   * @param f The function that returns a `ResultAsync` to apply to the current
+   * value
+   */
+  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+  /**
+   * Maps a `Result<T, E>` to `ResultAsync<U, E>`
+   * by applying an async function to a contained `Ok` value, leaving an `Err`
+   * value untouched.
+   *
+   * @param f An async function to apply an `OK` value
+   */
+  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+  /**
+   * Unwrap the `Ok` value, or return the default if there is an `Err`
+   *
+   * @param v the default value to return if there is an `Err`
+   */
+  unwrapOr<A>(v: A): T | A;
+  /**
+   *
+   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
+   * execute the function that matches the `Result` variant.
+   *
+   * Match callbacks do not necessitate to return a `Result`, however you can
+   * return a `Result` if you want to.
+   *
+   * `match` is like chaining `map` and `mapErr`, with the distinction that
+   * with `match` both functions must have the same return type.
+   *
+   * @param ok
+   * @param err
+   */
+  match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap(): Generator<Err<never, E>, T>;
+  /**
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+   *
+   * @param config
+   */
+  _unsafeUnwrap(config?: ErrorConfig): T;
+  /**
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+   * otherwise it throws a custom object.
+   *
+   * @param config
+   */
+  _unsafeUnwrapErr(config?: ErrorConfig): E;
+}
+declare class Ok<T, E> implements IResult<T, E> {
+  readonly value: T;
+  constructor(value: T);
+  isOk(): this is Ok<T, E>;
+  isErr(): this is Err<T, E>;
+  map<A>(f: (t: T) => A): Result<A, E>;
+  mapErr<U>(_f: (e: E) => U): Result<T, U>;
+  andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+  andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
+  andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+  andTee(f: (t: T) => unknown): Result<T, E>;
+  orTee(_f: (t: E) => unknown): Result<T, E>;
+  orElse<R extends Result<unknown, unknown>>(_f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<U, A>(_f: (e: E) => Result<U, A>): Result<U | T, A>;
+  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+  asyncAndThrough<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<T, InferAsyncErrTypes<R> | E>;
+  asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+  unwrapOr<A>(_v: A): T | A;
+  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
+  safeUnwrap(): Generator<Err<never, E>, T>;
+  _unsafeUnwrap(_?: ErrorConfig): T;
+  _unsafeUnwrapErr(config?: ErrorConfig): E;
+  [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+declare class Err<T, E> implements IResult<T, E> {
+  readonly error: E;
+  constructor(error: E);
+  isOk(): this is Ok<T, E>;
+  isErr(): this is Err<T, E>;
+  map<A>(_f: (t: T) => A): Result<A, E>;
+  mapErr<U>(f: (e: E) => U): Result<T, U>;
+  andThrough<F>(_f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+  andTee(_f: (t: T) => unknown): Result<T, E>;
+  orTee(f: (t: E) => unknown): Result<T, E>;
+  andThen<R extends Result<unknown, unknown>>(_f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+  andThen<U, F>(_f: (t: T) => Result<U, F>): Result<U, E | F>;
+  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
+  asyncAndThen<U, F>(_f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+  asyncAndThrough<F>(_f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+  asyncMap<U>(_f: (t: T) => Promise<U>): ResultAsync<U, E>;
+  unwrapOr<A>(v: A): T | A;
+  match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
+  safeUnwrap(): Generator<Err<never, E>, T>;
+  _unsafeUnwrap(config?: ErrorConfig): T;
+  _unsafeUnwrapErr(_?: ErrorConfig): E;
+  [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+declare type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
+declare type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
+declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+declare type Dedup<T> = T extends Result<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
+declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
+declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+declare type IsLiteralArray<T> = T extends {
+  length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+declare type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+declare type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
+declare type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+declare type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
+//#endregion
+//#region src/services/error/getResult.d.ts
+declare const getResult: <T>(fn: () => T) => Result<T, Error>;
+//#endregion
+//#region src/services/error/getResultAsync.d.ts
+declare const getResultAsync: <T>(fn: () => Promise<T>) => ResultAsync<T, Error>;
+//#endregion
+//#region src/services/error/toAppError.d.ts
+declare const toAppError: (error: unknown) => Error;
+//#endregion
+//#region src/services/error/withFinalizer.d.ts
+declare const withFinalizer: <T>(fn: () => T, finalizer?: () => void) => T;
+//#endregion
+//#region src/services/error/withFinalizerAsync.d.ts
+declare const withFinalizerAsync: <T>(fn: () => Promisable<T>, finalizer?: () => Promisable<void>) => Promise<T>;
+//#endregion
 //#region src/services/message/constants.d.ts
 declare const MENTION_ID_ATTRIBUTE = "data-id";
 declare const MENTION_LABEL_ATTRIBUTE = "data-label";
@@ -2370,6 +2717,9 @@ declare const takeOne: TakeOne;
 //#region src/util/environment/getIsServer.d.ts
 declare const getIsServer: () => boolean;
 //#endregion
+//#region src/util/function/noop.d.ts
+declare const noop: () => void;
+//#endregion
 //#region src/util/id/constants.d.ts
 declare const ID_SEPARATOR = "|";
 //#endregion
@@ -2400,6 +2750,9 @@ declare const escapeRegExp: (string: string) => string;
 //#region src/util/text/capitalize.d.ts
 declare const capitalize: (string: string) => string;
 //#endregion
+//#region src/util/text/normalizeString.d.ts
+declare const normalizeString: (value: null | string | undefined) => string;
+//#endregion
 //#region src/util/text/streamToText.d.ts
 declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
 //#endregion
@@ -2458,4 +2811,4 @@ declare const UUIDV4_REGEX: RegExp;
 //#region src/util/id/uuid/uuidValidateV4.d.ts
 declare const uuidValidateV4: (uuid: string) => boolean;
 //#endregion
-export { AllSpecialValues, BuildTuple, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GetPaths, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };
+export { AllSpecialValues, BuildTuple, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GetArrayProps, GetObjectProps, GetPaths, GetPrimitiveProps, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KnownKeys, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };

package/dist/index.js

@@ -27,6 +27,9 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
+//#region src/util/function/noop.ts
+const noop = () => {};
+//#endregion
 //#region src/test/constants.ts
 const AllSpecialValues = [
 	{
@@ -67,11 +70,11 @@ const AllSpecialValues = [
 	},
 	{
 		isPlainObject: false,
-		value: () => {}
+		value: noop
 	},
 	{
 		isPlainObject: false,
-		value: /* @__PURE__ */ new RegExp("")
+		value: /* @__PURE__ */ new RegExp("", "u")
 	}
 ];
 //#endregion
@@ -180,9 +183,9 @@ let Operation = /* @__PURE__ */ function(Operation) {
 	return Operation;
 }({});
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+shared@3.5.33/node_modules/@vue/shared/dist/shared.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.34/node_modules/@vue/shared/dist/shared.esm-bundler.js
 /**
-* @vue/shared v3.5.33
+* @vue/shared v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -195,7 +198,6 @@ function makeMap(str) {
 const EMPTY_OBJ = Object.freeze({});
 Object.freeze([]);
 const NOOP = () => {};
-const NO = () => false;
 const extend = Object.assign;
 const remove = (arr, el) => {
 	const i = arr.indexOf(el);
@@ -226,18 +228,9 @@ const cacheStringFunction$1 = (fn) => {
 		return cache[str] || (cache[str] = fn(str));
 	});
 };
-const camelizeRE$1 = /-\w/g;
-cacheStringFunction$1((str) => {
-	return str.replace(camelizeRE$1, (c) => c.slice(1).toUpperCase());
-});
-const hyphenateRE$1 = /\B([A-Z])/g;
-cacheStringFunction$1((str) => str.replace(hyphenateRE$1, "-$1").toLowerCase());
 const capitalize$1 = cacheStringFunction$1((str) => {
 	return str.charAt(0).toUpperCase() + str.slice(1);
 });
-const toHandlerKey = cacheStringFunction$1((str) => {
-	return str ? `on${capitalize$1(str)}` : ``;
-});
 const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
 const def = (obj, key, value, writable = false) => {
 	Object.defineProperty(obj, key, {
@@ -252,9 +245,9 @@ const getGlobalThis = () => {
 	return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.33/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.34/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
 /**
-* @vue/reactivity v3.5.33
+* @vue/reactivity v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -1354,9 +1347,9 @@ function traverse(value, depth = Infinity, seen) {
 	return value;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.33/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.34/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
 /**
-* @vue/runtime-core v3.5.33
+* @vue/runtime-core v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -1828,34 +1821,6 @@ function createPathGetter(ctx, path) {
 }
 getGlobalThis().requestIdleCallback;
 getGlobalThis().cancelIdleCallback;
-function injectHook(type, hook, target = currentInstance, prepend = false) {
-	if (target) {
-		const hooks = target[type] || (target[type] = []);
-		const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-			pauseTracking();
-			const reset = setCurrentInstance(target);
-			const res = callWithAsyncErrorHandling(hook, target, type, args);
-			reset();
-			resetTracking();
-			return res;
-		});
-		if (prepend) hooks.unshift(wrappedHook);
-		else hooks.push(wrappedHook);
-		return wrappedHook;
-	} else warn$1(`${toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""))} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
-}
-const createHook = (lifecycle) => (hook, target = currentInstance) => {
-	if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
-};
-createHook("bm");
-createHook("m");
-createHook("bu");
-createHook("u");
-createHook("bum");
-createHook("um");
-createHook("sp");
-createHook("rtg");
-createHook("rtc");
 const getPublicInstance = (i) => {
 	if (!i) return null;
 	if (isStatefulComponent(i)) return getComponentPublicInstance(i);
@@ -1911,10 +1876,8 @@ const PublicInstanceProxyHandlers = {
 		const publicGetter = publicPropertiesMap[key];
 		let cssModule, globalProperties;
 		if (publicGetter) {
-			if (key === "$attrs") {
-				track(instance.attrs, "get", "");
-				markAttrsAccessed();
-			} else if (key === "$slots") track(instance, "get", key);
+			if (key === "$attrs") track(instance.attrs, "get", "");
+			else if (key === "$slots") track(instance, "get", key);
 			return publicGetter(instance);
 		} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
 		else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
@@ -2056,36 +2019,13 @@ function mergeWatchOptions(to, from) {
 	for (const key in from) merged[key] = mergeAsArray(to[key], from[key]);
 	return merged;
 }
-function createAppContext() {
-	return {
-		app: null,
-		config: {
-			isNativeTag: NO,
-			performance: false,
-			globalProperties: {},
-			optionMergeStrategies: {},
-			errorHandler: void 0,
-			warnHandler: void 0,
-			compilerOptions: {}
-		},
-		mixins: [],
-		components: {},
-		directives: {},
-		provides: /* @__PURE__ */ Object.create(null),
-		optionsCache: /* @__PURE__ */ new WeakMap(),
-		propsCache: /* @__PURE__ */ new WeakMap(),
-		emitsCache: /* @__PURE__ */ new WeakMap()
-	};
-}
 let currentApp = null;
-function markAttrsAccessed() {}
 const queuePostRenderEffect = queueEffectWithSuspense;
 function queueEffectWithSuspense(fn, suspense) {
 	if (suspense && suspense.pendingBranch) if (isArray(fn)) suspense.effects.push(...fn);
 	else suspense.effects.push(fn);
 	else queuePostFlushCb(fn);
 }
-createAppContext();
 let currentInstance = null;
 const getCurrentInstance = () => currentInstance || currentRenderingInstance;
 let internalSetCurrentInstance;
@@ -2313,9 +2253,9 @@ function initCustomFormatter() {
 	else window.devtoolsFormatters = [formatter];
 }
 //#endregion
-//#region ../../node_modules/.pnpm/vue@3.5.33_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+//#region ../../node_modules/.pnpm/vue@3.5.34_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
 /**
-* vue v3.5.33
+* vue v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -2329,18 +2269,6 @@ const getRawData = (data) => /* @__PURE__ */ isReactive(data) ? /* @__PURE__ */
 typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
 const toString = Object.prototype.toString;
 const isObject = (val) => toString.call(val) === "[object Object]";
-function cacheStringFunction(fn) {
-	const cache = Object.create(null);
-	return ((str) => {
-		return cache[str] || (cache[str] = fn(str));
-	});
-}
-const hyphenateRE = /\B([A-Z])/g;
-cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-const camelizeRE = /-(\w)/g;
-cacheStringFunction((str) => {
-	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-});
 //#endregion
 //#region src/util/reactivity/toRawDeep.ts
 const toRawDeep = (data) => {
@@ -2360,6 +2288,507 @@ var Serializable = class {
 	}
 };
 //#endregion
+//#region src/services/error/toAppError.ts
+const toAppError = (error) => {
+	if (error instanceof Error) return error;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return new Error(error.message, { cause: error });
+	return new Error(String(error), { cause: error });
+};
+//#endregion
+//#region ../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
+const defaultErrorConfig = { withStackTrace: false };
+const createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+	return {
+		data: result.isOk() ? {
+			type: "Ok",
+			value: result.value
+		} : {
+			type: "Err",
+			value: result.error
+		},
+		message,
+		stack: config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0
+	};
+};
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+function __awaiter(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+}
+function __values(o) {
+	var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+	if (m) return m.call(o);
+	if (o && typeof o.length === "number") return { next: function() {
+		if (o && i >= o.length) o = void 0;
+		return {
+			value: o && o[i++],
+			done: !o
+		};
+	} };
+	throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+	return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	var g = generator.apply(thisArg, _arguments || []), i, q = [];
+	return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i;
+	function awaitReturn(f) {
+		return function(v) {
+			return Promise.resolve(v).then(f, reject);
+		};
+	}
+	function verb(n, f) {
+		if (g[n]) {
+			i[n] = function(v) {
+				return new Promise(function(a, b) {
+					q.push([
+						n,
+						v,
+						a,
+						b
+					]) > 1 || resume(n, v);
+				});
+			};
+			if (f) i[n] = f(i[n]);
+		}
+	}
+	function resume(n, v) {
+		try {
+			step(g[n](v));
+		} catch (e) {
+			settle(q[0][3], e);
+		}
+	}
+	function step(r) {
+		r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+	}
+	function fulfill(value) {
+		resume("next", value);
+	}
+	function reject(value) {
+		resume("throw", value);
+	}
+	function settle(f, v) {
+		if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+	}
+}
+function __asyncDelegator(o) {
+	var i, p;
+	return i = {}, verb("next"), verb("throw", function(e) {
+		throw e;
+	}), verb("return"), i[Symbol.iterator] = function() {
+		return this;
+	}, i;
+	function verb(n, f) {
+		i[n] = o[n] ? function(v) {
+			return (p = !p) ? {
+				value: __await(o[n](v)),
+				done: false
+			} : f ? f(v) : v;
+		} : f;
+	}
+}
+function __asyncValues(o) {
+	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	var m = o[Symbol.asyncIterator], i;
+	return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i);
+	function verb(n) {
+		i[n] = o[n] && function(v) {
+			return new Promise(function(resolve, reject) {
+				v = o[n](v), settle(resolve, reject, v.done, v.value);
+			});
+		};
+	}
+	function settle(resolve, reject, d, v) {
+		Promise.resolve(v).then(function(v) {
+			resolve({
+				value: v,
+				done: d
+			});
+		}, reject);
+	}
+}
+var ResultAsync = class ResultAsync {
+	constructor(res) {
+		this._promise = res;
+	}
+	static fromSafePromise(promise) {
+		return new ResultAsync(promise.then((value) => new Ok(value)));
+	}
+	static fromPromise(promise, errorFn) {
+		return new ResultAsync(promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e))));
+	}
+	static fromThrowable(fn, errorFn) {
+		return (...args) => {
+			return new ResultAsync(__awaiter(this, void 0, void 0, function* () {
+				try {
+					return new Ok(yield fn(...args));
+				} catch (error) {
+					return new Err(errorFn ? errorFn(error) : error);
+				}
+			}));
+		};
+	}
+	static combine(asyncResultList) {
+		return combineResultAsyncList(asyncResultList);
+	}
+	static combineWithAllErrors(asyncResultList) {
+		return combineResultAsyncListWithAllErrors(asyncResultList);
+	}
+	map(f) {
+		return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+			if (res.isErr()) return new Err(res.error);
+			return new Ok(yield f(res.value));
+		})));
+	}
+	andThrough(f) {
+		return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+			if (res.isErr()) return new Err(res.error);
+			const newRes = yield f(res.value);
+			if (newRes.isErr()) return new Err(newRes.error);
+			return new Ok(res.value);
+		})));
+	}
+	andTee(f) {
+		return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+			if (res.isErr()) return new Err(res.error);
+			try {
+				yield f(res.value);
+			} catch (e) {}
+			return new Ok(res.value);
+		})));
+	}
+	orTee(f) {
+		return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+			if (res.isOk()) return new Ok(res.value);
+			try {
+				yield f(res.error);
+			} catch (e) {}
+			return new Err(res.error);
+		})));
+	}
+	mapErr(f) {
+		return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+			if (res.isOk()) return new Ok(res.value);
+			return new Err(yield f(res.error));
+		})));
+	}
+	andThen(f) {
+		return new ResultAsync(this._promise.then((res) => {
+			if (res.isErr()) return new Err(res.error);
+			const newValue = f(res.value);
+			return newValue instanceof ResultAsync ? newValue._promise : newValue;
+		}));
+	}
+	orElse(f) {
+		return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+			if (res.isErr()) return f(res.error);
+			return new Ok(res.value);
+		})));
+	}
+	match(ok, _err) {
+		return this._promise.then((res) => res.match(ok, _err));
+	}
+	unwrapOr(t) {
+		return this._promise.then((res) => res.unwrapOr(t));
+	}
+	/**
+	* @deprecated will be removed in 9.0.0.
+	*
+	* You can use `safeTry` without this method.
+	* @example
+	* ```typescript
+	* safeTry(async function* () {
+	*   const okValue = yield* yourResult
+	* })
+	* ```
+	* Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+	*/
+	safeUnwrap() {
+		return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+			return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+		});
+	}
+	then(successCallback, failureCallback) {
+		return this._promise.then(successCallback, failureCallback);
+	}
+	[Symbol.asyncIterator]() {
+		return __asyncGenerator(this, arguments, function* _a() {
+			const result = yield __await(this._promise);
+			if (result.isErr()) yield yield __await(errAsync(result.error));
+			return yield __await(result.value);
+		});
+	}
+};
+function errAsync(err) {
+	return new ResultAsync(Promise.resolve(new Err(err)));
+}
+ResultAsync.fromPromise;
+ResultAsync.fromSafePromise;
+ResultAsync.fromThrowable;
+/**
+* Short circuits on the FIRST Err value that we find
+*/
+const combineResultList = (resultList) => {
+	let acc = ok([]);
+	for (const result of resultList) if (result.isErr()) {
+		acc = err(result.error);
+		break;
+	} else acc.map((list) => list.push(result.value));
+	return acc;
+};
+const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+/**
+* Give a list of all the errors we find
+*/
+const combineResultListWithAllErrors = (resultList) => {
+	let acc = ok([]);
+	for (const result of resultList) if (result.isErr() && acc.isErr()) acc.error.push(result.error);
+	else if (result.isErr() && acc.isOk()) acc = err([result.error]);
+	else if (result.isOk() && acc.isOk()) acc.value.push(result.value);
+	return acc;
+};
+const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result) {
+	/**
+	* Wraps a function with a try catch, creating a new function with the same
+	* arguments but returning `Ok` if successful, `Err` if the function throws
+	*
+	* @param fn function to wrap with ok on success or err on failure
+	* @param errorFn when an error is thrown, this will wrap the error result if provided
+	*/
+	function fromThrowable(fn, errorFn) {
+		return (...args) => {
+			try {
+				return ok(fn(...args));
+			} catch (e) {
+				return err(errorFn ? errorFn(e) : e);
+			}
+		};
+	}
+	Result.fromThrowable = fromThrowable;
+	function combine(resultList) {
+		return combineResultList(resultList);
+	}
+	Result.combine = combine;
+	function combineWithAllErrors(resultList) {
+		return combineResultListWithAllErrors(resultList);
+	}
+	Result.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+function ok(value) {
+	return new Ok(value);
+}
+function err(err) {
+	return new Err(err);
+}
+var Ok = class {
+	constructor(value) {
+		this.value = value;
+	}
+	isOk() {
+		return true;
+	}
+	isErr() {
+		return !this.isOk();
+	}
+	map(f) {
+		return ok(f(this.value));
+	}
+	mapErr(_f) {
+		return ok(this.value);
+	}
+	andThen(f) {
+		return f(this.value);
+	}
+	andThrough(f) {
+		return f(this.value).map((_value) => this.value);
+	}
+	andTee(f) {
+		try {
+			f(this.value);
+		} catch (e) {}
+		return ok(this.value);
+	}
+	orTee(_f) {
+		return ok(this.value);
+	}
+	orElse(_f) {
+		return ok(this.value);
+	}
+	asyncAndThen(f) {
+		return f(this.value);
+	}
+	asyncAndThrough(f) {
+		return f(this.value).map(() => this.value);
+	}
+	asyncMap(f) {
+		return ResultAsync.fromSafePromise(f(this.value));
+	}
+	unwrapOr(_v) {
+		return this.value;
+	}
+	match(ok, _err) {
+		return ok(this.value);
+	}
+	safeUnwrap() {
+		const value = this.value;
+		return (function* () {
+			return value;
+		})();
+	}
+	_unsafeUnwrap(_) {
+		return this.value;
+	}
+	_unsafeUnwrapErr(config) {
+		throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+	}
+	*[Symbol.iterator]() {
+		return this.value;
+	}
+};
+var Err = class {
+	constructor(error) {
+		this.error = error;
+	}
+	isOk() {
+		return false;
+	}
+	isErr() {
+		return !this.isOk();
+	}
+	map(_f) {
+		return err(this.error);
+	}
+	mapErr(f) {
+		return err(f(this.error));
+	}
+	andThrough(_f) {
+		return err(this.error);
+	}
+	andTee(_f) {
+		return err(this.error);
+	}
+	orTee(f) {
+		try {
+			f(this.error);
+		} catch (e) {}
+		return err(this.error);
+	}
+	andThen(_f) {
+		return err(this.error);
+	}
+	orElse(f) {
+		return f(this.error);
+	}
+	asyncAndThen(_f) {
+		return errAsync(this.error);
+	}
+	asyncAndThrough(_f) {
+		return errAsync(this.error);
+	}
+	asyncMap(_f) {
+		return errAsync(this.error);
+	}
+	unwrapOr(v) {
+		return v;
+	}
+	match(_ok, err) {
+		return err(this.error);
+	}
+	safeUnwrap() {
+		const error = this.error;
+		return (function* () {
+			yield err(error);
+			throw new Error("Do not use this generator out of `safeTry`");
+		})();
+	}
+	_unsafeUnwrap(config) {
+		throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+	}
+	_unsafeUnwrapErr(_) {
+		return this.error;
+	}
+	*[Symbol.iterator]() {
+		const self = this;
+		yield self;
+		return self;
+	}
+};
+const fromThrowable = Result.fromThrowable;
+//#endregion
+//#region src/services/error/getResult.ts
+const getResult = (fn) => fromThrowable(fn, toAppError)();
+//#endregion
+//#region src/services/error/getResultAsync.ts
+const getResultAsync = (fn) => ResultAsync.fromPromise(Promise.resolve().then(fn), toAppError);
+//#endregion
+//#region src/services/error/withFinalizer.ts
+const withFinalizer = (fn, finalizer) => {
+	const result = getResult(fn);
+	(finalizer ? getResult(finalizer) : void 0)?.match(noop, (error) => {
+		throw error;
+	});
+	return result.match((value) => value, (error) => {
+		throw error;
+	});
+};
+//#endregion
+//#region src/services/error/withFinalizerAsync.ts
+const withFinalizerAsync = async (fn, finalizer) => {
+	const result = await getResultAsync(async () => fn());
+	if (finalizer) await getResultAsync(async () => finalizer()).match(noop, (error) => {
+		if (result.isOk()) throw error;
+		console.error(error);
+	});
+	return result.match((value) => value, (error) => {
+		throw error;
+	});
+};
+//#endregion
 //#region src/services/message/constants.ts
 const MENTION_ID_ATTRIBUTE = "data-id";
 const MENTION_LABEL_ATTRIBUTE = "data-label";
@@ -14385,17 +14814,17 @@ const isPlainObject = (data) => {
 };
 //#endregion
 //#region src/util/object/jsonDateParse.ts
-const reISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.{0,1}\d*))(?:Z|(\+|-)([\d|:]*))?$/;
-const reMsAjax = /^\/Date\((d|-|.*)\)[/|\\]$/;
+const ISO_DATE_REGEX = new RegExp(String.raw`^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.{0,1}\d*))(?:Z|(\+|-)([\d|:]*))?$`, "u");
+const MS_AJAX_DATE_REGEX = new RegExp(String.raw`^\/Date\((d|-|.*)\)[\/|\\]$`, "u");
 const jsonDateParse = (text) => JSON.parse(text, (_key, value) => {
 	let parsedValue = value;
 	if (typeof value === "string") {
-		let a = reISO.exec(value);
+		let a = ISO_DATE_REGEX.exec(value);
 		if (a) parsedValue = new Date(value);
 		else {
-			a = reMsAjax.exec(value);
+			a = MS_AJAX_DATE_REGEX.exec(value);
 			if (a) {
-				const b = takeOne(a, 1).split(/[-+,.]/);
+				const b = takeOne(a, 1).split(new RegExp(String.raw`[-+,.]`, "u"));
 				parsedValue = new Date(b[0] ? Number(b[0]) : 0 - Number(b[1]));
 			}
 		}
@@ -14407,11 +14836,14 @@ const jsonDateParse = (text) => JSON.parse(text, (_key, value) => {
 const mergeObjectsStrict = (...objects) => Object.assign({}, ...objects);
 //#endregion
 //#region src/util/regex/escapeRegExp.ts
-const escapeRegExp = (string) => string.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+const escapeRegExp = (string) => string.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
 //#endregion
 //#region src/util/text/capitalize.ts
 const capitalize = (string) => `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
 //#endregion
+//#region src/util/text/normalizeString.ts
+const normalizeString = (value) => value?.trim() ?? "";
+//#endregion
 //#region src/util/text/streamToText.ts
 const streamToText = async (readable) => {
 	readable.setEncoding("utf8");
@@ -14421,7 +14853,7 @@ const streamToText = async (readable) => {
 };
 //#endregion
 //#region src/util/text/toKebabCase.ts
-const toKebabCase = (string) => string.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)?.map((x) => x.toLowerCase()).join("-") ?? "";
+const toKebabCase = (string) => string.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/gu)?.map((x) => x.toLowerCase()).join("-") ?? "";
 //#endregion
 //#region src/util/text/truncate.ts
 const truncate = (string, length) => string.length > length ? `${string.slice(0, length)}..."` : string;
@@ -14458,9 +14890,9 @@ const exhaustiveGuard = (value) => {
 //#endregion
 //#region src/util/id/uuid/constants.ts
 const NIL = "00000000-0000-0000-0000-000000000000";
-const UUIDV4_REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
+const UUIDV4_REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu;
 //#endregion
 //#region src/util/id/uuid/uuidValidateV4.ts
 const uuidValidateV4 = (uuid) => UUIDV4_REGEX.test(uuid);
 //#endregion
-export { AllSpecialValues, ForbiddenError, ID_SEPARATOR, InvalidOperationError, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, NIL, NotFoundError, NotInitializedError, Operation, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, UUIDV4_REGEX, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };
+export { AllSpecialValues, ForbiddenError, ID_SEPARATOR, InvalidOperationError, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, NIL, NotFoundError, NotInitializedError, Operation, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, UUIDV4_REGEX, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esposter/shared",
-  "version": "2.22.0",
+  "version": "2.23.0",
   "description": "A library that contains shared typescript code.",
   "homepage": "https://github.com/Esposter/Esposter/blob/main/packages/shared#readme",
   "bugs": {
@@ -33,13 +33,13 @@
     "typecheck": "tsgo"
   },
   "dependencies": {
-    "@vueuse/core": "^14.2.1",
+    "@vueuse/core": "^14.3.0",
     "node-html-parser": "^7.1.0",
-    "vue": "^3.5.33",
-    "zod": "^4.3.6"
+    "vue": "^3.5.34",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@azure/data-tables": "^13.3.2"
   },
-  "gitHead": "405a6743bb0fdae18c07faff17037b9e7a345939"
+  "gitHead": "b5172e2824227a4b5e9524a4945f521a70ff5c9d"
 }