effective-progress 0.5.0 → 0.5.2

package/src/terminal.ts

@@ -1,61 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-
-export 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>;
-}
-
-const withRawInputCapture: ProgressTerminalService["withRawInputCapture"] = (effect) =>
-  Effect.suspend(() => {
-    if (!process.stdin.isTTY) {
-      return effect;
-    }
-
-    const stdin = process.stdin;
-    const wasRaw = Boolean(stdin.isRaw);
-    const onData = (chunk: Buffer) => {
-      if (chunk.length === 1 && chunk[0] === 3) {
-        process.kill(process.pid, "SIGINT");
-      }
-    };
-
-    return Effect.acquireUseRelease(
-      Effect.sync(() => {
-        stdin.resume();
-        stdin.setRawMode?.(true);
-        stdin.on("data", onData);
-      }),
-      () => effect,
-      () =>
-        Effect.sync(() => {
-          try {
-            stdin.off("data", onData);
-            stdin.setRawMode?.(wasRaw);
-            stdin.pause();
-          } catch {
-            // Best effort terminal restoration.
-          }
-        }),
-    );
-  });
-
-const defaultTerminalService: ProgressTerminalService = {
-  isTTY: Effect.sync(() => Boolean(process.stderr.isTTY)),
-  stderrRows: Effect.sync(() => process.stderr.rows),
-  stderrColumns: Effect.sync(() => process.stderr.columns),
-  writeStderr: (text) =>
-    Effect.sync(() => {
-      process.stderr.write(text);
-    }),
-  withRawInputCapture,
-};
-
-export class ProgressTerminal extends Context.Tag("stromseng.dev/ProgressTerminal")<
-  ProgressTerminal,
-  ProgressTerminalService
->() {
-  static readonly Default = Layer.succeed(ProgressTerminal, defaultTerminalService);
-}

package/src/types.ts

@@ -1,143 +0,0 @@
-import { Brand, Context, Effect, Option, Schema } from "effect";
-
-const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
-
-export type TaskId = typeof TaskIdSchema.Type;
-export const TaskId = Brand.nominal<TaskId>();
-
-export const TaskStatusSchema = Schema.Literal("running", "done", "failed");
-
-export type TaskStatus = typeof TaskStatusSchema.Type;
-
-export interface AddTaskOptions {
-  readonly description: string;
-  readonly total?: number;
-  readonly transient?: boolean;
-  readonly parentId?: TaskId;
-}
-
-export interface UpdateTaskOptions {
-  readonly description?: string;
-  readonly completed?: number;
-  readonly total?: number;
-  readonly transient?: boolean;
-}
-
-export type TrackOptions = Exclude<AddTaskOptions, "parentId">;
-
-export class DeterminateTaskUnits extends Schema.TaggedClass<DeterminateTaskUnits>()(
-  "DeterminateTaskUnits",
-  {
-    completed: Schema.Number,
-    total: Schema.Number,
-  },
-) {}
-
-export class IndeterminateTaskUnits extends Schema.TaggedClass<IndeterminateTaskUnits>()(
-  "IndeterminateTaskUnits",
-  {
-    spinnerFrame: Schema.Number,
-  },
-) {}
-
-export const TaskUnitsSchema = Schema.Union(DeterminateTaskUnits, IndeterminateTaskUnits);
-
-export type TaskUnits = typeof TaskUnitsSchema.Type;
-
-export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapshot", {
-  id: TaskIdSchema,
-  parentId: Schema.NullOr(TaskIdSchema),
-  description: Schema.String,
-  status: TaskStatusSchema,
-  transient: Schema.Boolean,
-  units: TaskUnitsSchema,
-  startedAt: Schema.Number,
-  completedAt: Schema.NullOr(Schema.Number),
-}) {}
-
-export interface RenderRow {
-  readonly id: TaskId;
-  readonly depth: number;
-}
-
-export interface TaskStore {
-  readonly tasks: Map<TaskId, TaskSnapshot>;
-  readonly renderOrder: ReadonlyArray<RenderRow>;
-}
-
-export 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>>;
-  };
-}
-
-export class Task extends Context.Tag("stromseng.dev/effective-progress/Task")<Task, TaskId>() {}
-
-export class TaskAddedEvent extends Schema.TaggedClass<TaskAddedEvent>()("TaskAdded", {
-  taskId: TaskIdSchema,
-  parentId: Schema.NullOr(TaskIdSchema),
-  description: Schema.String,
-  total: Schema.optional(Schema.Number),
-  transient: Schema.Boolean,
-}) {}
-
-export class TaskUpdatedEvent extends Schema.TaggedClass<TaskUpdatedEvent>()("TaskUpdated", {
-  taskId: TaskIdSchema,
-  description: Schema.optional(Schema.String),
-  completed: Schema.optional(Schema.Number),
-  total: Schema.optional(Schema.Number),
-  transient: Schema.optional(Schema.Boolean),
-}) {}
-
-export class TaskAdvancedEvent extends Schema.TaggedClass<TaskAdvancedEvent>()("TaskAdvanced", {
-  taskId: TaskIdSchema,
-  amount: Schema.Number,
-}) {}
-
-export class TaskCompletedEvent extends Schema.TaggedClass<TaskCompletedEvent>()("TaskCompleted", {
-  taskId: TaskIdSchema,
-}) {}
-
-export class TaskFailedEvent extends Schema.TaggedClass<TaskFailedEvent>()("TaskFailed", {
-  taskId: TaskIdSchema,
-}) {}
-
-export class TaskRemovedEvent extends Schema.TaggedClass<TaskRemovedEvent>()("TaskRemoved", {
-  taskId: TaskIdSchema,
-}) {}
-
-export const ProgressTaskEventSchema = Schema.Union(
-  TaskAddedEvent,
-  TaskUpdatedEvent,
-  TaskAdvancedEvent,
-  TaskCompletedEvent,
-  TaskFailedEvent,
-  TaskRemovedEvent,
-);
-
-export type ProgressTaskEvent = typeof ProgressTaskEventSchema.Type;
-
-export const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema);

package/src/utils.ts

@@ -1,20 +0,0 @@
-export const inferTotal = (iterable: Iterable<unknown>): number | undefined => {
-  if (Array.isArray(iterable)) {
-    return iterable.length;
-  }
-
-  if (typeof iterable === "string") {
-    return iterable.length;
-  }
-
-  const candidate = iterable as { length?: unknown; size?: unknown };
-  if (typeof candidate.length === "number") {
-    return candidate.length;
-  }
-
-  if (typeof candidate.size === "number") {
-    return candidate.size;
-  }
-
-  return undefined;
-};