@haltcase/run 2.0.1 → 3.0.1

package/dist/cli/bin.js

@@ -5,4 +5,3 @@ const handler = createHandler();
 void main({
     handler
 });
-//# sourceMappingURL=bin.js.map

package/dist/cli/handler.js

@@ -1,8 +1,8 @@
 import { readdirSync } from "node:fs";
 import { extname } from "node:path";
 import { Spinner } from "@favware/colorette-spinner";
-import cliui from "@isaacs/cliui";
-import { bold, yellow } from "colorette";
+import cliui from "cliui";
+import { bold, gray, yellow } from "colorette";
 import { isBrandedTask } from "../tasks/guards.js";
 import { getSchemaProperties } from "../util/getSchemaProperties.js";
 import { extensions } from "../util/resolveTaskFile.js";
@@ -41,7 +41,7 @@ export const taskListHandler = (context) => {
         wrap: true
     });
     const { config } = context.taskFile.data;
-    const baseUsage = usage.replace("<action>", context.taskFile.name);
+    const baseUsage = usage.replace("<taskFile>", context.taskFile.name);
     ui.div(`${baseUsage} <parameter> [...options]`);
     ui.div({
         text: "Available tasks:",
@@ -58,13 +58,12 @@ export const taskListHandler = (context) => {
         const formattedName = bold(name);
         if (isBrandedTask(value)) {
             if (value.kind === "strictTask") {
-                const properties = getSchemaProperties(value.schema);
-                const { description = "" } = value.schema;
+                const properties = getSchemaProperties(value.schema) || gray("not available");
                 ui.div({
                     text: formattedName,
                     width: nameColumnWidth,
                     padding: [0, taskListPaddingX, 0, taskListPaddingX]
-                }, ...[properties, description].filter(Boolean));
+                }, properties);
                 continue;
             }
             ui.div({
@@ -104,4 +103,3 @@ export const createHandler = () => {
         failWith: (message) => failWith(spinner, message)
     };
 };
-//# sourceMappingURL=handler.js.map

package/dist/cli/main.js

@@ -33,6 +33,11 @@ export const main = async (props) => {
             resolutions.map((it) => `  ${it}`).join("\n")
         ]);
     }
+    // update context with the fully resolved file path
+    context.taskFile = {
+        ...parse(resolutions),
+        path: resolutions
+    };
     const taskFileResult = await loadTaskFile(context);
     if (!taskFileResult.ok) {
         props.handler.failWith(taskFileResult.error);
@@ -57,4 +62,3 @@ export const main = async (props) => {
         props.handler.failWith([`Failed to execute task`, String(error)]);
     }
 };
-//# sourceMappingURL=main.js.map

package/dist/cli/parseOptions.js

@@ -46,4 +46,3 @@ export const parseOptions = (args) => {
     }
     return options;
 };
-//# sourceMappingURL=parseOptions.js.map

package/dist/config.js

@@ -14,4 +14,3 @@ export const getAppConfig = async () => {
         }
     });
 };
-//# sourceMappingURL=config.js.map

package/dist/index.js

@@ -1,2 +1 @@
 export { task } from "./tasks/task.js";
-//# sourceMappingURL=index.js.map

package/dist/tasks/executeTask.js

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 import { $, execa } from "execa";
 const execaInherited = execa({
     stdin: "inherit",
@@ -22,8 +21,8 @@ export const executeTask = async (context, options) => {
             context.handler.failWith(`Task name is required.`);
         }
         context.handler.failWith([
-            `Task file '${context.taskFile.base}' does not export '${context.taskName}'`,
-            `Resolved to: ${join(context.taskFile.dir, context.taskFile.base)}`
+            `Task file '${context.taskFile.name}' does not export '${context.taskName}'`,
+            `Resolved to: ${context.taskFile.path}`
         ]);
     }
     try {
@@ -44,4 +43,3 @@ export const executeTask = async (context, options) => {
         context.handler.failWith([`Failed to execute ${specifier}`, message]);
     }
 };
-//# sourceMappingURL=executeTask.js.map

package/dist/tasks/guards.d.ts

@@ -1,3 +1,3 @@
 import type { BrandedTask, BrandedTaskStrict, Task } from "./types.js";
 export declare const isBrandedTask: (task: Task) => task is BrandedTask;
-export declare const isBrandedTaskStrict: (task: Task) => task is BrandedTaskStrict;
+export declare const isBrandedTaskStrict: <T>(task: Task<T>) => task is BrandedTaskStrict<T>;

package/dist/tasks/guards.js

@@ -1,3 +1,2 @@
 export const isBrandedTask = (task) => "kind" in task;
 export const isBrandedTaskStrict = (task) => "kind" in task && task.kind === "strictTask";
-//# sourceMappingURL=guards.js.map

package/dist/tasks/task.d.ts

@@ -1,7 +1,14 @@
-import { z } from "zod";
-import type { Defined, Merge } from "../util/types.js";
-import type { BrandedTask, BrandedTaskStrict, DefaultOptionsInput, SchemaDefaults, SchemaInput, Task } from "./types.js";
+import type { Type } from "arktype";
+import { type } from "arktype";
+import type { BrandedTask, BrandedTaskStrict, DefaultOptionsInput, Task } from "./types.js";
 export declare const task: {
     <T = DefaultOptionsInput>(fn: Task<T>): BrandedTask<T>;
-    strict<TShape extends Partial<SchemaInput>, TSchema extends z.ZodObject<Merge<SchemaDefaults, Defined<TShape>>> = z.ZodObject<Merge<SchemaDefaults, Defined<TShape>>, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<Merge<SchemaDefaults, Defined<TShape>>>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<Merge<SchemaDefaults, Defined<TShape>>>, any>[k]; } : never, z.baseObjectInputType<Merge<SchemaDefaults, Defined<TShape>>> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<Merge<SchemaDefaults, Defined<TShape>>>[k_1]; } : never>>(shape: TShape, fn: Task<z.infer<TSchema>>): BrandedTaskStrict<TSchema>;
+    strict<const TShape>(shape: type.validate<TShape>, fn: Task<NoInfer<Type<type.infer<TShape>>["infer"]>>): BrandedTaskStrict<Type<type.infer<TShape>>["inferIn"]>;
 };
+/**
+ * Default schema for the options received by a {@link task}.
+ */
+export declare const defaultOptionsInput: import("arktype/internal/methods/object.ts").ObjectType<{
+    _: string[];
+    env: Record<string, string | undefined>;
+}, {}>;

package/dist/tasks/task.js

@@ -1,49 +1,55 @@
+import { type } from "arktype";
 import { red } from "colorette";
-import { z } from "zod";
-import { fromZodError } from "zod-validation-error";
-const zodMessageBuilder = (issues) => issues
-    .map((issue) => {
-    const propertyName = issue.path[0];
-    if (issue.code === "unrecognized_keys") {
-        const keyList = issue.keys.map((key) => `--${key}`).join(", ");
-        return `${red("Unrecognized options")}: ${keyList}`;
-    }
+const formatValidationIssues = (errors) => errors
+    .map((error) => {
+    const propertyName = String(error.path[0]);
+    const dottedPath = error.path.join(".");
     if (!propertyName) {
-        return issue.message;
+        return error.message;
     }
+    const messageWithoutProperty = error.message.startsWith(dottedPath)
+        ? error.message.slice(dottedPath.length + 1)
+        : error.message;
     if (propertyName === "env") {
-        const prefix = red(`Environment variable '${issue.path[1]}'`);
-        return `${prefix}: ${issue.message}`;
+        const prefix = red(`Environment variable '${String(error.path[1])}'`);
+        return `${prefix}: ${messageWithoutProperty}`;
     }
     const optionText = propertyName === "_" ? "Positionals" : `--${propertyName}`;
+    if (error.code === "predicate" && error.expected === "removed") {
+        return `${red(optionText)}: unknown option`;
+    }
     // we currently assume there is only ever one path segment
-    return `${red(optionText)}: ${issue.message}`;
+    return `${red(optionText)}: ${messageWithoutProperty}`;
 })
     .join("\n");
 export const task = (fn) => {
     fn.kind = "task";
     return fn;
 };
+/**
+ * Default schema for the options received by a {@link task}.
+ */
+export const defaultOptionsInput = type({
+    _: "string[]",
+    env: "Record<string, string | undefined>"
+});
+/**
+ * Create a task that validates its input against a schema.
+ */
 task.strict = (shape, fn) => {
-    const defaultValidators = {
-        _: z.string().array(),
-        env: z.object({}).passthrough()
-    };
-    const schema = z.strictObject({
-        ...defaultValidators,
-        ...shape
-    });
+    const schema = defaultOptionsInput
+        .merge(type.raw(shape))
+        .onUndeclaredKey("reject");
     const taskFunction = (options, utilities) => {
-        const { data, success, error } = schema.safeParse(options);
-        if (!success) {
-            throw new Error(fromZodError(error, { messageBuilder: zodMessageBuilder }).message, {
-                cause: error
+        const validationResult = schema(options);
+        if (validationResult instanceof type.errors) {
+            throw new TypeError(formatValidationIssues(validationResult), {
+                cause: validationResult
             });
         }
-        return fn(data, utilities);
+        return fn(validationResult, utilities);
     };
     taskFunction.kind = "strictTask";
     taskFunction.schema = schema;
     return taskFunction;
 };
-//# sourceMappingURL=task.js.map

package/dist/tasks/types.d.ts

@@ -1,5 +1,5 @@
+import type { Type } from "arktype";
 import type { ExecaMethod, ExecaScriptMethod } from "execa";
-import type { z } from "zod";
 import type { ParsedOptions } from "../cli/parseOptions.js";
 export interface TaskUtilities {
     /**
@@ -39,27 +39,20 @@ export interface TaskUtilities {
         stderr: "inherit";
     }>;
 }
-export type CustomShape = Record<string, z.ZodTypeAny>;
-export interface SchemaInput {
-    _: z.ZodType<any, z.ZodTypeDef, string[]>;
-    env: z.ZodType<any, z.ZodTypeDef, Record<string, string | undefined>>;
-    [key: string]: z.ZodTypeAny;
-}
-export interface SchemaDefaults {
-    _: z.ZodArray<z.ZodString>;
-    env: z.ZodObject<Record<string, z.ZodOptional<z.ZodString>>>;
-}
 export type DefaultOptionsInput = ParsedOptions & {
     env: Record<string, string | undefined>;
 };
 export type TaskCollection = Partial<Record<string, Task>>;
-export type Task<TOptions = DefaultOptionsInput> = (options: TOptions, utilities: TaskUtilities) => unknown;
-export type BrandedTaskStrict<TSchema extends z.ZodTypeAny = z.ZodType<DefaultOptionsInput>> = Task<z.input<TSchema>> & {
+type MergePositionals<TOptions> = "_" extends keyof TOptions ? TOptions : TOptions & ParsedOptions;
+type MergeEnvironment<TOptions> = "env" extends keyof TOptions ? TOptions : TOptions & Pick<DefaultOptionsInput, "env">;
+export type Task<TOptions = unknown> = (options: MergePositionals<MergeEnvironment<TOptions>>, utilities: TaskUtilities) => unknown;
+export type BrandedTaskStrict<TShape = DefaultOptionsInput> = Task<TShape> & {
     kind: "strictTask";
-    schema: TSchema;
+    schema: Type<TShape>;
 };
-export type BrandedTaskLoose<TOptions = DefaultOptionsInput> = Task<TOptions> & {
+export type BrandedTaskLoose<TOptions = unknown> = Task<TOptions> & {
     kind: "task";
     schema: never;
 };
-export type BrandedTask<TOptions = DefaultOptionsInput> = BrandedTaskLoose<TOptions> | BrandedTaskStrict<z.ZodType<TOptions>>;
+export type BrandedTask<TOptions = unknown> = BrandedTaskLoose<TOptions> | BrandedTaskStrict<TOptions>;
+export {};

package/dist/tasks/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map