effective-progress 0.5.1 → 0.5.3

package/dist/index.d.mts

@@ -0,0 +1,179 @@
+import { Brand, Context, Effect, Layer, Option, Schema } from "effect";
+import { Concurrency } from "effect/Types";
+import * as effect_SchemaAST0 from "effect/SchemaAST";
+
+//#region src/types.d.ts
+declare const TaskIdSchema: Schema.brand<typeof Schema.Number, "TaskId">;
+type TaskId = typeof TaskIdSchema.Type;
+declare const TaskId: Brand.Brand.Constructor<number & Brand.Brand<"TaskId">>;
+declare const TaskStatusSchema: Schema.Literal<["running", "done", "failed"]>;
+type TaskStatus = typeof TaskStatusSchema.Type;
+interface AddTaskOptions {
+  readonly description: string;
+  readonly total?: number;
+  readonly transient?: boolean;
+  readonly parentId?: TaskId;
+}
+interface UpdateTaskOptions {
+  readonly description?: string;
+  readonly completed?: number;
+  readonly total?: number;
+  readonly transient?: boolean;
+}
+type TrackOptions = Exclude<AddTaskOptions, "parentId">;
+declare const DeterminateTaskUnits_base: Schema.TaggedClass<DeterminateTaskUnits, "DeterminateTaskUnits", {
+  readonly _tag: Schema.tag<"DeterminateTaskUnits">;
+} & {
+  completed: typeof Schema.Number;
+  total: typeof Schema.Number;
+}>;
+declare class DeterminateTaskUnits extends DeterminateTaskUnits_base {}
+declare const IndeterminateTaskUnits_base: Schema.TaggedClass<IndeterminateTaskUnits, "IndeterminateTaskUnits", {
+  readonly _tag: Schema.tag<"IndeterminateTaskUnits">;
+} & {
+  spinnerFrame: typeof Schema.Number;
+}>;
+declare class IndeterminateTaskUnits extends IndeterminateTaskUnits_base {}
+declare const TaskUnitsSchema: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
+type TaskUnits = typeof TaskUnitsSchema.Type;
+declare const TaskSnapshot_base: Schema.TaggedClass<TaskSnapshot, "TaskSnapshot", {
+  readonly _tag: Schema.tag<"TaskSnapshot">;
+} & {
+  id: Schema.brand<typeof Schema.Number, "TaskId">;
+  parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
+  description: typeof Schema.String;
+  status: Schema.Literal<["running", "done", "failed"]>;
+  transient: typeof Schema.Boolean;
+  units: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
+  startedAt: typeof Schema.Number;
+  completedAt: Schema.NullOr<typeof Schema.Number>;
+}>;
+declare class TaskSnapshot extends TaskSnapshot_base {}
+interface RenderRow {
+  readonly id: TaskId;
+  readonly depth: number;
+}
+interface TaskStore {
+  readonly tasks: Map<TaskId, TaskSnapshot>;
+  readonly renderOrder: ReadonlyArray<RenderRow>;
+}
+interface ProgressService {
+  readonly addTask: (options: AddTaskOptions) => Effect.Effect<TaskId>;
+  readonly updateTask: (taskId: TaskId, options: UpdateTaskOptions) => Effect.Effect<void>;
+  readonly advanceTask: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
+  readonly completeTask: (taskId: TaskId) => Effect.Effect<void>;
+  readonly failTask: (taskId: TaskId) => Effect.Effect<void>;
+  readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
+  readonly getTask: (taskId: TaskId) => Effect.Effect<Option.Option<TaskSnapshot>>;
+  readonly listTasks: Effect.Effect<ReadonlyArray<TaskSnapshot>>;
+  readonly runTask: {
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions): Effect.Effect<A, E, Exclude<R, Task>>;
+    <A, E, R>(options: AddTaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Task>>;
+  };
+  readonly withTask: {
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions): Effect.Effect<A, E, Exclude<R, Task>>;
+    <A, E, R>(options: AddTaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Task>>;
+  };
+}
+declare const Task_base: Context.TagClass<Task, "stromseng.dev/effective-progress/Task", number & Brand.Brand<"TaskId">>;
+declare class Task extends Task_base {}
+declare const TaskAddedEvent_base: Schema.TaggedClass<TaskAddedEvent, "TaskAdded", {
+  readonly _tag: Schema.tag<"TaskAdded">;
+} & {
+  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
+  parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
+  description: typeof Schema.String;
+  total: Schema.optional<typeof Schema.Number>;
+  transient: typeof Schema.Boolean;
+}>;
+declare class TaskAddedEvent extends TaskAddedEvent_base {}
+declare const TaskUpdatedEvent_base: Schema.TaggedClass<TaskUpdatedEvent, "TaskUpdated", {
+  readonly _tag: Schema.tag<"TaskUpdated">;
+} & {
+  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
+  description: Schema.optional<typeof Schema.String>;
+  completed: Schema.optional<typeof Schema.Number>;
+  total: Schema.optional<typeof Schema.Number>;
+  transient: Schema.optional<typeof Schema.Boolean>;
+}>;
+declare class TaskUpdatedEvent extends TaskUpdatedEvent_base {}
+declare const TaskAdvancedEvent_base: Schema.TaggedClass<TaskAdvancedEvent, "TaskAdvanced", {
+  readonly _tag: Schema.tag<"TaskAdvanced">;
+} & {
+  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
+  amount: typeof Schema.Number;
+}>;
+declare class TaskAdvancedEvent extends TaskAdvancedEvent_base {}
+declare const TaskCompletedEvent_base: Schema.TaggedClass<TaskCompletedEvent, "TaskCompleted", {
+  readonly _tag: Schema.tag<"TaskCompleted">;
+} & {
+  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
+}>;
+declare class TaskCompletedEvent extends TaskCompletedEvent_base {}
+declare const TaskFailedEvent_base: Schema.TaggedClass<TaskFailedEvent, "TaskFailed", {
+  readonly _tag: Schema.tag<"TaskFailed">;
+} & {
+  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
+}>;
+declare class TaskFailedEvent extends TaskFailedEvent_base {}
+declare const TaskRemovedEvent_base: Schema.TaggedClass<TaskRemovedEvent, "TaskRemoved", {
+  readonly _tag: Schema.tag<"TaskRemoved">;
+} & {
+  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
+}>;
+declare class TaskRemovedEvent extends TaskRemovedEvent_base {}
+declare const ProgressTaskEventSchema: Schema.Union<[typeof TaskAddedEvent, typeof TaskUpdatedEvent, typeof TaskAdvancedEvent, typeof TaskCompletedEvent, typeof TaskFailedEvent, typeof TaskRemovedEvent]>;
+type ProgressTaskEvent = typeof ProgressTaskEventSchema.Type;
+declare const decodeProgressTaskEvent: (u: unknown, overrideOptions?: effect_SchemaAST0.ParseOptions) => TaskAddedEvent | TaskUpdatedEvent | TaskAdvancedEvent | TaskCompletedEvent | TaskFailedEvent | TaskRemovedEvent;
+//#endregion
+//#region src/runtime.d.ts
+declare const Progress_base: Context.TagClass<Progress, "stromseng.dev/effective-progress/Progress", ProgressService>;
+declare class Progress extends Progress_base {
+  static readonly Default: Layer.Layer<Progress, never, never>;
+}
+//#endregion
+//#region src/api.d.ts
+interface EffectExecutionOptions {
+  readonly concurrency?: Concurrency;
+  readonly batching?: boolean | "inherit";
+  readonly concurrentFinalizers?: boolean;
+}
+interface EffectAllExecutionOptions extends EffectExecutionOptions {
+  readonly discard?: boolean;
+  readonly mode?: "default" | "validate" | "either";
+}
+type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
+type AllReturn<Arg extends ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>, O extends EffectAllExecutionOptions> = [[Arg] extends [ReadonlyArray<Effect.Effect<any, any, any>>] ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : [Arg] extends [Record<string, Effect.Effect<any, any, any>>] ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : never] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>> : never;
+interface ForEachExecutionOptions extends EffectExecutionOptions {
+  readonly discard?: false | undefined;
+}
+type ForEachOptions = TrackOptions & ForEachExecutionOptions;
+type TaskOptions = AddTaskOptions;
+declare const task: {
+  <A, E, R>(effect: Effect.Effect<A, E, R>, options: TaskOptions): Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+  <A, E, R>(options: TaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+};
+type AllArg = ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>;
+declare const all: {
+  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(effects: Arg, options: Omit<TrackOptions, "total"> & O): AllReturn<Arg, O>;
+  <O extends EffectAllExecutionOptions>(options: Omit<TrackOptions, "total"> & O): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
+};
+declare const forEach: {
+  <A, B, E, R>(iterable: Iterable<A>, f: (item: A, index: number) => Effect.Effect<B, E, R>, options: ForEachOptions): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+  <A, B, E, R>(f: (item: A, index: number) => Effect.Effect<B, E, R>, options: ForEachOptions): (iterable: Iterable<A>) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+};
+//#endregion
+//#region src/terminal.d.ts
+interface ProgressTerminalService {
+  readonly isTTY: Effect.Effect<boolean>;
+  readonly stderrRows: Effect.Effect<number | undefined>;
+  readonly stderrColumns: Effect.Effect<number | undefined>;
+  readonly writeStderr: (text: string) => Effect.Effect<void>;
+  readonly withRawInputCapture: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+declare const ProgressTerminal_base: Context.TagClass<ProgressTerminal, "stromseng.dev/ProgressTerminal", ProgressTerminalService>;
+declare class ProgressTerminal extends ProgressTerminal_base {
+  static readonly Default: Layer.Layer<ProgressTerminal, never, never>;
+}
+//#endregion
+export { AddTaskOptions, AllOptions, AllReturn, DeterminateTaskUnits, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, IndeterminateTaskUnits, Progress, ProgressService, ProgressTaskEvent, ProgressTaskEventSchema, ProgressTerminal, ProgressTerminalService, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskId, TaskOptions, TaskRemovedEvent, TaskSnapshot, TaskStatus, TaskStatusSchema, TaskStore, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task };