@indietabletop/appkit 0.2.0 → 0.2.1

package/dist/append-copy-to-text.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Appends " (Copy)" to the end of the input string if it doesn't already end
+ * with " (Copy)", otherwise it appends a number after "Copy", incrementing it
+ * if necessary.
+ */
+export declare function appendCopyToText(input: string): string;
+/**
+ * Works like {@link appendCopyToText}, but ignores empty strings.
+ */
+export declare function maybeAppendCopyToText(input: string): string;

package/dist/append-copy-to-text.js

@@ -0,0 +1,29 @@
+/**
+ * Appends " (Copy)" to the end of the input string if it doesn't already end
+ * with " (Copy)", otherwise it appends a number after "Copy", incrementing it
+ * if necessary.
+ */
+export function appendCopyToText(input) {
+    const regex = /^(?<value>.*) \(Copy(?: (?<count>\d+))?\)$/;
+    const match = input.match(regex);
+    // If there isn't a match, we directly append to the input.
+    if (!match) {
+        return `${input.trim()} (Copy)`;
+    }
+    const { value, count } = match.groups ?? {};
+    // If `count` capturing group is not present, it means that the input ends
+    // with the copy suffix, but it doesn't contain count.
+    const nextCount = !count ? 2 : parseInt(count, 10) + 1;
+    return `${value.trim()} (Copy ${nextCount})`;
+}
+/**
+ * Works like {@link appendCopyToText}, but ignores empty strings.
+ */
+export function maybeAppendCopyToText(input) {
+    // If input is falsy (i.e. empty string) then we don't want to append
+    // anything to it.
+    if (!input) {
+        return "";
+    }
+    return appendCopyToText(input);
+}

package/dist/async-op.d.ts

@@ -0,0 +1,75 @@
+type Falsy = null | undefined | false | 0 | 0n | "";
+type Truthy<T> = Exclude<T, Falsy>;
+interface Operation<SuccessValue, FailureValue> {
+    readonly type: "SUCCESS" | "FAILURE" | "PENDING";
+    readonly isPending: boolean;
+    readonly isSuccess: boolean;
+    readonly isFailure: boolean;
+    val: SuccessValue | FailureValue | null;
+    valueOrNull(): SuccessValue | null;
+    valueOrThrow(): SuccessValue;
+    hasTruthyValue(): boolean;
+    failureValueOrNull(): FailureValue | null;
+    failureValueOrThrow(): FailureValue;
+    flatMap<T extends AsyncOp<unknown, unknown>>(mappingFn: (value: SuccessValue) => T): T | Failure<FailureValue> | Pending;
+    mapSuccess<MappedSuccess>(mappingFn: (value: SuccessValue) => MappedSuccess): Operation<MappedSuccess, FailureValue>;
+    mapFailure<MappedFailure>(mappingFn: (value: FailureValue) => MappedFailure): Operation<SuccessValue, MappedFailure>;
+    unpack<S, F, P>(mapS: (value: SuccessValue) => S, mapF: (failure: FailureValue) => F, mapP: () => P): S | F | P;
+}
+export declare class Pending implements Operation<never, never> {
+    readonly type: "PENDING";
+    readonly isPending: true;
+    readonly isSuccess: false;
+    readonly isFailure: false;
+    val: null;
+    valueOrNull(): null;
+    valueOrThrow(): never;
+    hasTruthyValue(): false;
+    failureValueOrNull(): null;
+    failureValueOrThrow(): never;
+    flatMap(): Pending;
+    mapSuccess(): Pending;
+    mapFailure(): Pending;
+    unpack<S, F, P>(_mapS: (value: never) => S, _mapF: (failure: never) => F, mapP: () => P): S | F | P;
+}
+export declare class Success<SuccessValue> implements Operation<SuccessValue, never> {
+    readonly type: "SUCCESS";
+    readonly isPending: false;
+    readonly isSuccess: true;
+    readonly isFailure: false;
+    readonly value: SuccessValue;
+    readonly val: SuccessValue;
+    constructor(value: SuccessValue);
+    valueOrNull(): SuccessValue;
+    valueOrThrow(): SuccessValue;
+    hasTruthyValue(): this is Success<Truthy<SuccessValue>>;
+    failureValueOrNull(): null;
+    failureValueOrThrow(): never;
+    flatMap<T extends AsyncOp<unknown, unknown>>(mappingFn: (value: SuccessValue) => T): T;
+    mapSuccess<MappedValue>(mappingFn: (value: SuccessValue) => MappedValue): Success<MappedValue>;
+    mapFailure(): Success<SuccessValue>;
+    unpack<S, F, P>(mapS: (value: SuccessValue) => S, _mapF: (failure: never) => F, _mapP: () => P): S | F | P;
+}
+export declare class Failure<FailureValue> implements Operation<never, FailureValue> {
+    readonly type: "FAILURE";
+    readonly isPending: false;
+    readonly isSuccess: false;
+    readonly isFailure: true;
+    readonly failure: FailureValue;
+    readonly val: FailureValue;
+    constructor(failure: FailureValue);
+    valueOrNull(): null;
+    valueOrThrow(): never;
+    hasTruthyValue(): false;
+    failureValueOrNull(): FailureValue;
+    failureValueOrThrow(): FailureValue;
+    flatMap(): Failure<FailureValue>;
+    mapSuccess(): Failure<FailureValue>;
+    mapFailure<MappedFailure>(mappingFn: (value: FailureValue) => MappedFailure): Failure<MappedFailure>;
+    unpack<S, F, P>(_mapS: (value: never) => S, mapF: (failure: FailureValue) => F, _mapP: () => P): S | F | P;
+}
+export declare function fold<Ops extends readonly AsyncOp<unknown, unknown>[] | []>(ops: Ops): AsyncOp<{
+    -readonly [Index in keyof Ops]: Ops[Index] extends AsyncOp<infer S, unknown> ? S : never;
+}, Ops[number] extends AsyncOp<unknown, infer F> ? F : never>;
+export type AsyncOp<SuccessValue, FailureValue> = Pending | Success<SuccessValue> | Failure<FailureValue>;
+export {};

package/dist/async-op.js

@@ -0,0 +1,209 @@
+export class Pending {
+    constructor() {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "PENDING"
+        });
+        Object.defineProperty(this, "isPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "isSuccess", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isFailure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "val", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    valueOrNull() {
+        return null;
+    }
+    valueOrThrow() {
+        throw new Error(`AsyncOp value was accessed but the op is in Pending state.`);
+    }
+    hasTruthyValue() {
+        return false;
+    }
+    failureValueOrNull() {
+        return null;
+    }
+    failureValueOrThrow() {
+        throw new Error(`AsyncOp failure value was accessed but the op is in Pending state.`);
+    }
+    flatMap() {
+        return new Pending();
+    }
+    mapSuccess() {
+        return new Pending();
+    }
+    mapFailure() {
+        return new Pending();
+    }
+    unpack(_mapS, _mapF, mapP) {
+        return mapP();
+    }
+}
+export class Success {
+    constructor(value) {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "SUCCESS"
+        });
+        Object.defineProperty(this, "isPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isSuccess", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "isFailure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "val", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.value = value;
+        this.val = value;
+    }
+    valueOrNull() {
+        return this.value;
+    }
+    valueOrThrow() {
+        return this.value;
+    }
+    hasTruthyValue() {
+        return !!this.value;
+    }
+    failureValueOrNull() {
+        return null;
+    }
+    failureValueOrThrow() {
+        throw new Error(`AsyncOp failure value was accessed but the op is in Success state.`);
+    }
+    flatMap(mappingFn) {
+        return mappingFn(this.value);
+    }
+    mapSuccess(mappingFn) {
+        return new Success(mappingFn(this.value));
+    }
+    mapFailure() {
+        return new Success(this.value);
+    }
+    unpack(mapS, _mapF, _mapP) {
+        return mapS(this.value);
+    }
+}
+export class Failure {
+    constructor(failure) {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "FAILURE"
+        });
+        Object.defineProperty(this, "isPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isSuccess", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isFailure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "failure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "val", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.failure = failure;
+        this.val = failure;
+    }
+    valueOrNull() {
+        return null;
+    }
+    valueOrThrow() {
+        throw new Error(`AsyncOp value was accessed but the op is in Failure state.`);
+    }
+    hasTruthyValue() {
+        return false;
+    }
+    failureValueOrNull() {
+        return this.failure;
+    }
+    failureValueOrThrow() {
+        return this.failure;
+    }
+    flatMap() {
+        return new Failure(this.failure);
+    }
+    mapSuccess() {
+        return new Failure(this.failure);
+    }
+    mapFailure(mappingFn) {
+        return new Failure(mappingFn(this.failure));
+    }
+    unpack(_mapS, mapF, _mapP) {
+        return mapF(this.failure);
+    }
+}
+export function fold(ops) {
+    if (ops.every((v) => v.isSuccess)) {
+        return new Success(ops.map((op) => op.value));
+    }
+    const firstFail = ops.find((op) => op.isFailure);
+    if (firstFail) {
+        return firstFail;
+    }
+    return new Pending();
+}

package/dist/caught-value.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Safely returns a string from an unknown value.
+ *
+ * This function is intended to be used when handling values caught
+ * in try/catch blocks.
+ *
+ * In JS/TS, unless errors are returned, they cannot be properly typed
+ * because any code within the try block can throw. Additionally, thrown
+ * values do not have to be Errors.
+ *
+ * This function makes sure to first assert if an Error was caught, and
+ * if so, returns its message. If a string was caught, it returns that.
+ * Otherwise, it returns "Unknown error".
+ */
+export declare function caughtValueToString(value: unknown): string;

package/dist/caught-value.js

@@ -0,0 +1,23 @@
+/**
+ * Safely returns a string from an unknown value.
+ *
+ * This function is intended to be used when handling values caught
+ * in try/catch blocks.
+ *
+ * In JS/TS, unless errors are returned, they cannot be properly typed
+ * because any code within the try block can throw. Additionally, thrown
+ * values do not have to be Errors.
+ *
+ * This function makes sure to first assert if an Error was caught, and
+ * if so, returns its message. If a string was caught, it returns that.
+ * Otherwise, it returns "Unknown error".
+ */
+export function caughtValueToString(value) {
+    if (value instanceof Error) {
+        return value.message;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return "Unknown error.";
+}

package/dist/class-names.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Combines a list of strings into a single string. Falsy values are ignored.
+ */
+export declare function classNames(...classNames: (string | false | null | undefined)[]): string;

package/dist/class-names.js

@@ -0,0 +1,6 @@
+/**
+ * Combines a list of strings into a single string. Falsy values are ignored.
+ */
+export function classNames(...classNames) {
+    return classNames.filter((c) => !!c).join(" ");
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@indietabletop/appkit",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A collection of modules used in apps built by Indie Tabletop Club",
   "private": false,
   "type": "module",
   "scripts": {
-    "release": "np",
+    "release": "npm run build && np",
     "build": "tsc",
     "test": "vitest"
   },