@stateward/plugin-errors 0.0.0-stage → 1.0.0

package/dist/result-type.d.ts

@@ -0,0 +1,18 @@
+import type ts from "@stateward/core/typescript";
+import { type TypeQueries } from "@stateward/core";
+/**
+ * How a value says it failed, read from its type (the project's own `Result`, no helper library): a union with `ok: true | false`, one with `success: true | false` (zod's
+ * `safeParse`), or a type with `isOk()` and `isErr()` (neverthrow). `named` is a type the
+ * `resultTypes` option names, whatever its shape.
+ */
+export type ResultShape = "ok" | "success" | "isErr" | "named";
+/**
+ * The shape of a Result an expression gives (once awaited), or undefined when it is not one.
+ * `names`: the `resultTypes` option (names or globs).
+ */
+export declare function resultShapeOf(node: ts.Node, types: TypeQueries, names: readonly string[]): ResultShape | undefined;
+/** Cuts `text` to `max` characters, ending in `…`, for a headline or an example line. */
+export declare function shorten(text: string, max: number): string;
+/** A hint's example: indented 4 spaces, one line per entry. */
+export declare function example(lines: readonly string[]): string;
+//# sourceMappingURL=result-type.d.ts.map

package/dist/result-type.js

@@ -0,0 +1,55 @@
+import { matchesName } from "@stateward/core";
+/**
+ * Whether a property tells the members of a union apart by `true` and `false`. An object with
+ * `ok: boolean` (a fetch `Response`) is not a union, so it is not a Result.
+ */
+function isBooleanTag(node, property, types) {
+    const found = types.awaitedTagsOf(node, property);
+    if (found === "missing" || found.members < 2 || typeof found.tags === "string")
+        return false;
+    return found.tags.map((tag) => tag.label).join(",") === "false,true";
+}
+/** Whether every member of a union (two or more) has the property: `isOk` on neverthrow's `Ok | Err`. */
+function hasOnEveryMember(node, property, types) {
+    const found = types.awaitedTagsOf(node, property);
+    return found !== "missing" && found.members >= 2;
+}
+/** The name a type is printed with, after the `Promise<…>` around it: `Result` in `Promise<Result<A, B>>`. */
+function printedName(node, types) {
+    let text = types.typeTextOf(node).trim();
+    while (/^(?:Promise|PromiseLike)</.test(text))
+        text = text.slice(text.indexOf("<") + 1);
+    return /^[A-Za-z_$][\w$.]*/.exec(text)?.[0];
+}
+/**
+ * The shape of a Result an expression gives (once awaited), or undefined when it is not one.
+ * `names`: the `resultTypes` option (names or globs).
+ */
+export function resultShapeOf(node, types, names) {
+    // A primitive (most calls written as a statement give `void`) has no property to tell its
+    // members apart: one question instead of four.
+    const primitive = types.isPrimitive(node);
+    if (!primitive) {
+        if (isBooleanTag(node, "ok", types))
+            return "ok";
+        if (isBooleanTag(node, "success", types))
+            return "success";
+        if (hasOnEveryMember(node, "isOk", types) && hasOnEveryMember(node, "isErr", types)) {
+            return "isErr";
+        }
+    }
+    if (names.length === 0)
+        return undefined;
+    const alias = types.awaitedAliasOf(node)?.name ?? printedName(node, types);
+    return alias !== undefined && matchesName(alias, names) ? "named" : undefined;
+}
+/** Cuts `text` to `max` characters, ending in `…`, for a headline or an example line. */
+export function shorten(text, max) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/** A hint's example: indented 4 spaces, one line per entry. */
+export function example(lines) {
+    return lines.map((line) => `    ${line}`).join("\n");
+}
+//# sourceMappingURL=result-type.js.map

package/dist/result-unchecked.d.ts

@@ -0,0 +1,2 @@
+export declare const resultUnchecked: import("@stateward/core").FileRule<Readonly<Record<string, never>>, "callers">;
+//# sourceMappingURL=result-unchecked.d.ts.map