@planet-matrix/mobius-model 0.9.0 → 0.10.1

package/src/request/fetch/nodejs.ts

@@ -229,7 +229,6 @@ export class NodejsFetch<
    */
   async getJson(): Promise<FetchOutputJsonData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.json() as FetchOutputJsonData<Output>
   }
 
@@ -238,7 +237,6 @@ export class NodejsFetch<
    */
   async getText(): Promise<FetchOutputTextData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.text() as FetchOutputTextData<Output>
   }
 
@@ -247,7 +245,6 @@ export class NodejsFetch<
    */
   async getBlob(): Promise<FetchOutputBlobData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.blob() as FetchOutputBlobData<Output>
   }
 
@@ -256,7 +253,6 @@ export class NodejsFetch<
    */
   async getArrayBuffer(): Promise<FetchOutputArrayBufferData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.arrayBuffer() as FetchOutputArrayBufferData<Output>
   }
 
@@ -270,7 +266,6 @@ export class NodejsFetch<
       throw new Error("Response body stream is unavailable.")
     }
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return response.body as FetchOutputStreamData<Output>
   }
 }

package/src/request/request/base.ts

@@ -131,7 +131,6 @@ export abstract class BaseRequest<R extends Resource = Resource> {
    * 从成功输出中提取成功数据。
    */
   protected extractSuccessData(response: ResourceSuccessOutput<R>): ResourceSuccessData<R> {
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return response['data'] as ResourceSuccessData<R>
   }
 
@@ -146,7 +145,6 @@ export abstract class BaseRequest<R extends Resource = Resource> {
    * 从错误输出中提取错误数据。
    */
   protected extractErrorData(response: ResourceErrorOutput<R>): ResourceErrorData<R> {
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return response['data'] as ResourceErrorData<R>
   }
 
@@ -159,7 +157,6 @@ export abstract class BaseRequest<R extends Resource = Resource> {
     const { fetchFactory, modifyRequestOptions } = this.options
 
     const preparedOptions = modifyRequestOptions !== undefined
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       ? modifyRequestOptions(options as RequestOptions<R["path"], R>)
       : options
 
@@ -184,7 +181,6 @@ export abstract class BaseRequest<R extends Resource = Resource> {
           data: ResourceOutput<Extract<R, { path: Path }>>
         }
       }[typeof responseType]
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       const preparedFetch = (fetchFactory ?? generalFetch)(preparedOptions) as BaseFetch<FetchInput, FetchOutput>
 
       if (responseType === "json") {

package/src/request/request/general.ts

@@ -50,7 +50,6 @@ export class GeneralRequest<R extends GeneralResource = GeneralResource>
   extends BaseRequest<GeneralResourceToResource<R>> {
   constructor(options: GeneralRequestOptions<R>) {
     const generatePatchOutput = (context: GeneratePatchOutputContext): ResourcePatchOutput<GeneralResourceToResource<R>> => {
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       return {
         status: "unknown",
         data: context

package/src/result/controller.ts

@@ -10,15 +10,19 @@ export class Controller<L, R> {
     return Right.isRight(target)
   }
 
-  private promise: Promise<Either<L, R>>
-  private resolve: (value: Either<L, R>) => void
+  protected promise: Promise<Either<L, R>>
+  protected resolve: (value: Either<L, R>) => void
+  protected reject: (value: L) => void
 
   constructor() {
     let _resolve: (value: Either<L, R>) => void
-    this.promise = new Promise((resolve) => {
+    let _reject: (value: L) => void
+    this.promise = new Promise((resolve, reject) => {
       _resolve = resolve
+      _reject = reject
     })
     this.resolve = _resolve!
+    this.reject = _reject!
   }
 
   get value(): Promise<Either<L, R>> {
@@ -46,9 +50,9 @@ export class Controller<L, R> {
   }
 }
 
-type ExtractLeft<E> = E extends Either<infer L, infer _> ? L : never
-type ExtractRight<E> = E extends Either<infer _, infer R> ? R : never
+type GetLeft<E> = E extends Either<infer L, infer _> ? L : never
+type GetRight<E> = E extends Either<infer _, infer R> ? R : never
 export const controllerFromEitherType = <E extends Either<unknown, unknown>>(
-): Controller<ExtractLeft<E>, ExtractRight<E>> => {
-  return new Controller<ExtractLeft<E>, ExtractRight<E>>()
+): Controller<GetLeft<E>, GetRight<E>> => {
+  return new Controller<GetLeft<E>, GetRight<E>>()
 }

package/src/result/either.ts

@@ -1,24 +1,26 @@
 
 // oxlint-disable-next-line typescript/no-explicit-any
-type AnyEither = Either<any, any>
-type GetRight<Eithers> = Eithers extends []
+export type AnyEither = Either<any, any>
+export type GetLeft<T> = T extends Either<infer Left, unknown> ? Left : never
+export type GetRight<T> = T extends Either<unknown, infer Right> ? Right : never
+export type GetRights<Eithers> = Eithers extends []
   ? []
   : (
-    Eithers extends [infer AssumeEither, ...infer xs]
+    Eithers extends [infer Item, ...infer xs]
     ? (
-      AssumeEither extends Either<unknown, infer Right>
-      ? [Right, ...GetRight<xs>]
+      Item extends Either<unknown, infer Right>
+      ? [Right, ...GetRights<xs>]
       : never
     )
     : never
   )
-type GetLeft<Eithers> = Eithers extends []
+export type GetLefts<Eithers> = Eithers extends []
   ? []
   : (
-    Eithers extends [infer AssumeEither, ...infer xs]
+    Eithers extends [infer Item, ...infer xs]
     ? (
-      AssumeEither extends Either<infer Left, unknown>
-      ? [Left, ...GetLeft<xs>]
+      Item extends Either<infer Left, unknown>
+      ? [Left, ...GetLefts<xs>]
       : never
     )
     : never
@@ -26,72 +28,115 @@ type GetLeft<Eithers> = Eithers extends []
 type TupleToUnion<Tuple> = Tuple extends unknown[] ? Tuple[number] : never
 
 export abstract class Either<L, R> {
+  static isEither<L, R>(target: unknown): target is Either<L, R> {
+    return target instanceof Either
+  }
+
+  static isLeft<L, R>(target: unknown): target is Left<L, R> {
+    return Left.isLeft(target)
+  }
+
+  static isRight<L, R>(target: unknown): target is Right<L, R> {
+    return Right.isRight(target)
+  }
+
+  static left<L>(value: L): Either<L, never>
+  static left<L, R>(value: L): Either<L, R>
   static left<L, R>(value: L): Either<L, R> {
     return new Left(value)
   }
 
+  static right<R>(value: R): Either<never, R>
+  static right<L, R>(value: R): Either<L, R>
   static right<L, R>(value: R): Either<L, R> {
     return new Right(value)
   }
 
+  static pure<R>(value: R): Either<never, R>
+  static pure<L, R>(value: R): Either<L, R>
   static pure<L, R>(value: R): Either<L, R> {
     return new Right(value)
   }
 
   static lift<NewR, Eithers extends AnyEither[]>(
     eithers: [...Eithers],
-    map: (eitherRights: GetRight<Eithers>) => NewR,
-  ): Either<TupleToUnion<GetLeft<Eithers>>, NewR> {
+    map: (eitherRights: GetRights<Eithers>) => NewR,
+  ): Either<TupleToUnion<GetLefts<Eithers>>, NewR> {
     const firstLeft = eithers.find(either => either.isLeft())
     if (firstLeft !== undefined) {
-      return firstLeft as Either<TupleToUnion<GetLeft<Eithers>>, NewR>
+      return firstLeft as Either<TupleToUnion<GetLefts<Eithers>>, NewR>
     }
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const rights = eithers.map(either => {
       // oxlint-disable-next-line typescript/no-unsafe-return
       return either.assertRight().getRight()
-    }) as GetRight<Eithers>
+    }) as GetRights<Eithers>
     const newRightValue = map(rights)
     return Either.pure(newRightValue)
   }
 
-  abstract map<NewR>(map: (value: R) => NewR): Either<L, NewR>
-  abstract mapLeft<NewL>(map: (value: L) => NewL): Either<NewL, R>
-  abstract bind<NewR>(bind: (value: R) => Either<L, NewR>): Either<L, NewR>
+  abstract getValue(): L | R
+
+  abstract getLeft(): L
+  abstract getRight(): R
+  abstract getRightOr(or: R): R
 
   abstract isLeft(): this is Left<L, R>
   abstract isRight(): this is Right<L, R>
-  abstract getValue(): L | R
 
   abstract assertLeft(): Left<L, R>
   abstract assertRight(): Right<L, R>
 
-  abstract match<X>(onLeft: (value: L) => X, onRight: (value: R) => X): X
+  abstract tap(effects: {
+    left?: ((value: L) => void) | undefined
+    right?: ((value: R) => void) | undefined
+  }): Either<L, R>
+  abstract tapLeft(effect: (value: L) => void): Either<L, R>
+  abstract tapRight(effect: (value: R) => void): Either<L, R>
+
+  abstract mapLeft<NewL>(map: (value: L) => NewL): Either<NewL, R>
+  abstract mapRight<NewR>(map: (value: R) => NewR): Either<L, NewR>
+  abstract bind<NewL, NewR>(bind: (value: R) => Either<NewL, NewR>): Either<L | NewL, NewR>
+  abstract bindAsync<NewL, NewR>(bind: (value: R) => Promise<Either<NewL, NewR>>): Promise<Either<L | NewL, NewR>>
+
+  abstract match<X>(
+    left: (value: L) => X,
+    right: (value: R) => X
+  ): X
+  abstract matchAsync<X>(
+    left: (value: L) => Promise<X>,
+    right: (value: R) => Promise<X>
+  ): Promise<X>
 
   abstract mplus(either: Either<L, R>): Either<L, R>
+
+  abstract [Symbol.iterator](): Generator<Either<L, R>, R, R>
+  // Async consumers can fall back to Symbol.iterator, but we still expose the
+  // same semantics explicitly so Either remains self-descriptive as an async iterable.
+  abstract [Symbol.asyncIterator](): AsyncGenerator<Either<L, R>, R, unknown>
 }
-export class Left<L, R> extends Either<L, R> {
-  static isLeft<L, R>(target: unknown): target is Left<L, R> {
-    return target instanceof Left
-  }
 
-  private value: L
+export class Left<L, R> extends Either<L, R> {
+  protected value: L
 
   constructor(value: L) {
     super()
     this.value = value
   }
 
-  map<NewR>(_map: (value: R) => NewR): Either<L, NewR> {
-    return new Left(this.value)
+  getValue(): L | R {
+    return this.value
   }
 
-  mapLeft<NewL>(map: (value: L) => NewL): Either<NewL, R> {
-    return new Left(map(this.value))
+  getLeft(): L {
+    return this.value
   }
 
-  bind<NewR>(_map: (value: R) => Either<L, NewR>): Either<L, NewR> {
-    return new Left(this.value)
+  getRight(): R {
+    throw new Error("Cannot get right value from Left")
+  }
+
+  getRightOr(or: R): R {
+    return or
   }
 
   isLeft(): this is Left<L, R> {
@@ -102,53 +147,103 @@ export class Left<L, R> extends Either<L, R> {
     return false
   }
 
-  getLeft(): L {
-    return this.value
+  assertLeft(): this {
+    return this
   }
 
-  getValue(): L | R {
-    return this.value
+  assertRight(): Right<L, R> {
+    throw new Error("Assert failed")
   }
 
-  assertLeft(): this {
+  tap(effects: {
+    left?: ((value: L) => void) | undefined
+    right?: ((value: R) => void) | undefined
+  }): Either<L, R> {
+    if (effects.left !== undefined) {
+      effects.left(this.value)
+    }
     return this
   }
 
-  assertRight(): Right<L, R> {
-    throw new Error("Assert failed")
+  tapLeft(effect: (value: L) => void): Either<L, R> {
+    effect(this.value)
+    return this
+  }
+
+  tapRight(_effect: (value: R) => void): Either<L, R> {
+    return this
   }
 
-  match<X>(onLeft: (value: L) => X, _onRight: (value: R) => X): X {
-    return onLeft(this.value)
+  mapLeft<NewL>(map: (value: L) => NewL): Either<NewL, R> {
+    return new Left(map(this.value))
+  }
+
+  mapRight<NewR>(_map: (value: R) => NewR): Either<L, NewR> {
+    return new Left(this.value)
+  }
+
+  bind<NewL, NewR>(_map: (value: R) => Either<NewL, NewR>): Either<L | NewL, NewR> {
+    return new Left(this.value) as Either<L | NewL, NewR>
+  }
+
+  async bindAsync<NewL, NewR>(_bind: (value: R) => Promise<Either<NewL, NewR>>): Promise<Either<L | NewL, NewR>> {
+    return await Promise.resolve(new Left(this.value) as Either<L | NewL, NewR>)
+  }
+
+  match<X>(
+    left: (value: L) => X,
+    _right: (value: R) => X
+  ): X {
+    return left(this.value)
+  }
+
+  async matchAsync<X>(
+    left: (value: L) => Promise<X>,
+    _right: (value: R) => Promise<X>
+  ): Promise<X> {
+    return await left(this.value)
   }
 
   mplus(either: Either<L, R>): Either<L, R> {
     return either
   }
-}
 
-export class Right<L, R> extends Either<L, R> {
-  static isRight<L, R>(target: unknown): target is Right<L, R> {
-    return target instanceof Right
+  *[Symbol.iterator](): Generator<Either<L, R>, R, R> {
+    yield this
+    throw new Error("Cannot extract right value from Left")
+  }
+
+  // This mirrors the sync iterator exactly; it is explicit protocol support,
+  // not a requirement for async yield* fallback.
+  async *[Symbol.asyncIterator](): AsyncGenerator<Either<L, R>, R, unknown> {
+    await Promise.resolve()
+    yield this
+    throw new Error("Cannot extract right value from Left")
   }
+}
 
-  private value: R
+export class Right<L, R> extends Either<L, R> {
+  protected value: R
 
   constructor(value: R) {
     super()
     this.value = value
   }
 
-  map<NewR>(map: (value: R) => NewR): Either<L, NewR> {
-    return new Right(map(this.value))
+  getValue(): L | R {
+    return this.value
   }
 
-  mapLeft<NewL>(_map: (value: L) => NewL): Either<NewL, R> {
-    return new Right(this.value)
+  getLeft(): L {
+    throw new Error("Cannot get left value from Right")
+  }
+
+  getRight(): R {
+    return this.value
   }
 
-  bind<NewR>(map: (value: R) => Either<L, NewR>): Either<L, NewR> {
-    return map(this.value)
+  getRightOr(_or: R): R {
+    return this.value
   }
 
   isLeft(): this is Left<L, R> {
@@ -159,35 +254,110 @@ export class Right<L, R> extends Either<L, R> {
     return true
   }
 
-  getRight(): R {
-    return this.value
+  assertLeft(): Left<L, R> {
+    throw new Error("Assert failed")
   }
 
-  getValue(): L | R {
-    return this.value
+  assertRight(): this {
+    return this
   }
 
-  assertLeft(): Left<L, R> {
-    throw new Error("Assert failed")
+  tap(effects: {
+    left?: ((value: L) => void) | undefined
+    right?: ((value: R) => void) | undefined
+  }): Either<L, R> {
+    if (effects.right !== undefined) {
+      effects.right(this.value)
+    }
+    return this
   }
 
-  assertRight(): this {
+  tapLeft(_effect: (value: L) => void): Either<L, R> {
     return this
   }
 
-  match<X>(_onLeft: (value: L) => X, onRight: (value: R) => X): X {
-    return onRight(this.value)
+  tapRight(effect: (value: R) => void): Either<L, R> {
+    effect(this.value)
+    return this
+  }
+
+  mapLeft<NewL>(_map: (value: L) => NewL): Either<NewL, R> {
+    return new Right(this.value)
+  }
+
+  mapRight<NewR>(map: (value: R) => NewR): Either<L, NewR> {
+    return new Right(map(this.value))
+  }
+
+  bind<NewL, NewR>(map: (value: R) => Either<NewL, NewR>): Either<L | NewL, NewR> {
+    return map(this.value) as Either<L | NewL, NewR>
+  }
+
+  async bindAsync<NewL, NewR>(bind: (value: R) => Promise<Either<NewL, NewR>>): Promise<Either<L | NewL, NewR>> {
+    return await bind(this.value) as Either<L | NewL, NewR>
+  }
+
+  match<X>(
+    _left: (value: L) => X,
+    right: (value: R) => X
+  ): X {
+    return right(this.value)
+  }
+
+  async matchAsync<X>(
+    _left: (value: L) => Promise<X>,
+    right: (value: R) => Promise<X>
+  ): Promise<X> {
+    return await right(this.value)
   }
 
   mplus(_either: Either<L, R>): Either<L, R> {
     return this
   }
+
+  *[Symbol.iterator](): Generator<Either<L, R>, R, R> {
+    return this.value
+  }
+
+  // This mirrors the sync iterator exactly; async consumers could fall back to
+  // Symbol.iterator, but the explicit async form keeps the contract obvious.
+  async *[Symbol.asyncIterator](): AsyncGenerator<Either<L, R>, R, unknown> {
+    await Promise.resolve()
+    return this.value
+  }
+}
+
+export const isEither = <L, R>(target: unknown): target is Either<L, R> => {
+  return Either.isEither(target)
+}
+
+export const isLeft = <L, R>(target: unknown): target is Left<L, R> => {
+  return Left.isLeft(target)
+}
+
+export const isRight = <L, R>(target: unknown): target is Right<L, R> => {
+  return Right.isRight(target)
+}
+
+type LeftFunction = {
+  <L>(value: L): Either<L, never>
+  <L, R>(value: L): Either<L, R>
+}
+export const left = (<L, R>(value: L): Either<L, R> => {
+  return Either.left<L, R>(value)
+}) as LeftFunction
+
+type RightFunction = {
+  <R>(value: R): Either<never, R>
+  <L, R>(value: R): Either<L, R>
 }
+export const right = (<L, R>(value: R): Either<L, R> => {
+  return Either.right<L, R>(value)
+}) as RightFunction
 
 export type TupleOfEither<Left, Right> = [undefined, Right] | [Left, undefined]
 export const eitherToTuple = <L, R>(either: Either<L, R>): TupleOfEither<L, R> => {
   const left = either.isLeft() ? either.getLeft() : undefined
   const right = either.isRight() ? either.getRight() : undefined
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return [left, right] as TupleOfEither<L, R>
 }