@effect-app/vue 4.0.0-beta.6 → 4.0.0-beta.61

package/dist/commander.js

@@ -0,0 +1,556 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { asResult, reportRuntimeError } from "@effect-app/vue";
+import { reportMessage } from "@effect-app/vue/errorReporter";
+import { Cause, Context, Effect, flow, Layer, Match, MutableHashMap, Option, Predicate, S } from "effect-app";
+import { SupportedErrors } from "effect-app/client";
+import { OperationFailure, OperationSuccess } from "effect-app/Operations";
+import { isGeneratorFunction, wrapEffect } from "effect-app/utils";
+import { computed, reactive, ref } from "vue";
+import { Confirm } from "./confirm.js";
+import { I18n } from "./intl.js";
+import { WithToast } from "./withToast.js";
+export const DefaultIntl = {
+    de: {
+        "handle.confirmation": "{action} bestätigen?",
+        "handle.waiting": "{action} wird ausgeführt...",
+        "handle.success": "{action} erfolgreich",
+        "handle.with_errors": "{action} fehlgeschlagen",
+        "handle.with_warnings": "{action} erfolgreich, mit Warnungen",
+        "handle.error_response": "Die Anfrage war nicht erfolgreich:\n{error}\nWir wurden benachrichtigt und werden das Problem in Kürze beheben.",
+        "handle.response_error": "Die Antwort konnte nicht verarbeitet werden:\n{error}",
+        "handle.request_error": "Die Anfrage konnte nicht gesendet werden:\n{error}",
+        "handle.unexpected_error2": "{action} unerwarteter Fehler, probieren sie es in kurze nochmals.",
+        "handle.unexpected_error": "Unerwarteter Fehler:\n{error}",
+        "handle.not_found": "Das gesuchte war nicht gefunden"
+    },
+    en: {
+        "handle.confirmation": "Confirm {action}?",
+        "handle.waiting": "{action} executing...",
+        "handle.success": "{action} Success",
+        "handle.with_errors": "{action} Failed",
+        "handle.with_warnings": "{action}, with warnings",
+        "handle.error_response": "There was an error in processing the response:\n{error}\nWe have been notified and will fix the problem shortly.",
+        "handle.request_error": "There was an error in the request:\n{error}",
+        "handle.response_error": "The request was not successful:\n{error}",
+        "handle.unexpected_error2": "{action} unexpected error, please try again shortly.",
+        "handle.unexpected_error": "Unexpected Error:\n{error}",
+        "handle.not_found": "The requested item was not found."
+    }
+};
+export class CommandContext extends Context.Service()("CommandContext") {
+}
+/**
+ * Use to wrap emit calls with a callback to signal completion.
+ * Useful when the publisher wants to wait for the subscriber to finish processing.
+ */
+export const wrapEmit = (emit, event) => (value) => new Promise((resolve) => emit(event, value, resolve));
+const renderErrorMaker = I18n.useSync(({ intl }) => (action, errorRenderer) => (e, ...args) => {
+    if (errorRenderer) {
+        const m = errorRenderer(e, action, ...args);
+        if (m !== undefined) {
+            return m;
+        }
+    }
+    if (!S.is(SupportedErrors)(e) && !S.isSchemaError(e)) {
+        if (typeof e === "object" && e !== null) {
+            if ("message" in e) {
+                return `${e.message}`;
+            }
+            if ("_tag" in e) {
+                return `${e._tag}`;
+            }
+        }
+        return "";
+    }
+    const e2 = e;
+    return Match.value(e2).pipe(Match.tags({
+        NotFoundError: (e) => {
+            return intl.formatMessage({ id: "handle.not_found" }, { type: e.type, id: e.id });
+        },
+        SchemaError: (e) => {
+            console.warn(e.toString());
+            return intl.formatMessage({ id: "validation.failed" });
+        }
+    }), Match.orElse((e) => `${e.message ?? e._tag ?? e}`));
+});
+const defaultFailureMessageHandler = (actionMaker, errorRenderer) => Effect.fnUntraced(function* (o, ...args) {
+    const action = yield* wrapEffect(actionMaker)(o, ...args);
+    const { intl } = yield* I18n;
+    const renderError = yield* renderErrorMaker;
+    return Option.match(o, {
+        onNone: () => intl.formatMessage({ id: "handle.unexpected_error2" }, {
+            action,
+            error: "" // TODO consider again Cause.pretty(cause), // will be reported to Sentry/Otel anyway.. and we shouldn't bother users with error dumps?
+        }),
+        onSome: (e) => S.is(OperationFailure)(e)
+            ? {
+                level: "warn",
+                message: intl.formatMessage({ id: "handle.with_warnings" }, { action }) + e.message
+                    ? "\n" + e.message
+                    : ""
+            }
+            : `${intl.formatMessage({ id: "handle.with_errors" }, { action })}:\n` + renderError(action, errorRenderer)(e, ...args)
+    });
+});
+export const CommanderStatic = {
+    accessArgs: (cb) => (self, arg, arg2) => cb(arg, arg2)(self),
+    /** Version of @see confirmOrInterrupt that automatically includes the action name in the default messages */
+    confirmOrInterrupt: Effect.fnUntraced(function* (message = undefined) {
+        const context = yield* CommandContext;
+        const { intl } = yield* I18n;
+        yield* Confirm.confirmOrInterrupt(message
+            ?? intl.formatMessage({ id: "handle.confirmation" }, { action: context.action }));
+    }),
+    /** Version of @see confirm that automatically includes the action name in the default messages */
+    confirm: Effect.fnUntraced(function* (message = undefined) {
+        const context = yield* CommandContext;
+        const { intl } = yield* I18n;
+        return yield* Confirm.confirm(message
+            ?? intl.formatMessage({ id: "handle.confirmation" }, { action: context.action }));
+    }),
+    updateAction: (update) => (_, ...input) => Effect.updateService(_, CommandContext, (c) => ({ ...c, action: update(c.action, ...input) })),
+    defaultFailureMessageHandler,
+    renderError: renderErrorMaker,
+    /**
+     * Version of withDefaultToast that automatically includes the action name in the default messages and uses intl.
+     * uses the Command id as i18n namespace.  `action.{id}` is the main action name,
+     * and `action.{id}.waiting`, `action.{id}.success`, `action.{id}.failure` can be used to override the default messages for the respective states.
+     *
+     * the computed `state` provided to the Command can be used for interpolation in the i18n messages. (the state is captured at the start of each command execution and remains stable throughout)
+     *
+     * Note: if you provide `onWaiting` or `onSuccess` as `null`, no toast will be shown for that state.
+     * If you provide a string or function, it will be used instead of the i18n message.
+     * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
+     */
+    withDefaultToast: (options) => (self, ...args) => Effect.gen(function* () {
+        const cc = yield* CommandContext;
+        const { intl } = yield* I18n;
+        const withToast = yield* WithToast;
+        const customWaiting = cc.namespaced("waiting");
+        const hasCustomWaiting = !!intl.messages[customWaiting];
+        const customSuccess = cc.namespaced("success");
+        const hasCustomSuccess = !!intl.messages[customSuccess];
+        const customFailure = cc.namespaced("failure");
+        const hasCustomFailure = !!intl.messages[customFailure];
+        const stableToastId = options?.stableToastId
+            ? typeof options.stableToastId === "string"
+                ? options.stableToastId
+                : typeof options.stableToastId === "boolean"
+                    ? cc.id
+                    : typeof options.stableToastId === "function"
+                        ? (...args) => {
+                            const r = options.stableToastId(cc.id, ...args);
+                            if (typeof r === "string")
+                                return r;
+                            if (r === true)
+                                return cc.id;
+                            return undefined;
+                        }
+                        : undefined
+            : undefined;
+        return yield* self.pipe((_) => withToast({
+            onWaiting: options?.onWaiting === null ? null : hasCustomWaiting
+                ? intl.formatMessage({
+                    id: customWaiting
+                }, cc.state)
+                : intl.formatMessage({ id: "handle.waiting" }, { action: cc.action }),
+            onSuccess: options?.onSuccess === null
+                ? null
+                : (a, ..._args) => hasCustomSuccess
+                    ? intl.formatMessage({ id: customSuccess }, cc.state)
+                    : (intl.formatMessage({ id: "handle.success" }, { action: cc.action })
+                        + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
+            onFailure: defaultFailureMessageHandler(hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action, options?.errorRenderer),
+            stableToastId
+        })(_, ...args));
+    }),
+    /** borrowing the idea from Families in Effect Atom */
+    family: (maker, keyMaker) => {
+        const commands = MutableHashMap.empty();
+        const registry = new FinalizationRegistry((arg) => {
+            MutableHashMap.remove(commands, arg);
+        });
+        return (_k) => {
+            const k = keyMaker ? keyMaker(_k) : _k;
+            // we want to compare structurally, unless custom equal/hash has been implemented
+            const item = MutableHashMap.get(commands, k).pipe(Option.flatMap((r) => Option.fromNullishOr(r.deref())));
+            if (item.value) {
+                return item.value;
+            }
+            const v = maker(k);
+            MutableHashMap.set(commands, k, new WeakRef(v));
+            registry.register(v, k);
+            return v;
+        };
+    }
+};
+const makeBaseInfo = (id, options) => {
+    if (!id)
+        throw new Error("must specify an id");
+    const i18nKey = options?.i18nCustomKey ?? id;
+    const namespace = `action.${i18nKey}`;
+    const context = {
+        id,
+        i18nKey,
+        namespace,
+        namespaced: (k) => `${namespace}.${k}`
+    };
+    return context;
+};
+const waitState = ref({});
+const registerWait = (id) => {
+    // console.debug("register wait", id)
+    waitState.value[id] = waitState.value[id] ? waitState.value[id] + 1 : 1;
+};
+const unregisterWait = (id) => {
+    // console.debug("unregister wait", id)
+    if (waitState.value[id]) {
+        waitState.value[id] = waitState.value[id] - 1;
+        if (waitState.value[id] <= 0) {
+            delete waitState.value[id];
+        }
+    }
+};
+const getStateValues = (options) => {
+    const state_ = options?.state;
+    const state = !state_ ? computed(() => undefined) : typeof state_ === "function"
+        ? computed(state_)
+        : state_;
+    return state;
+};
+// class preserves JSDoc throughout..
+export class CommanderImpl {
+    rt;
+    intl;
+    hooks;
+    constructor(rt, intl, hooks) {
+        this.rt = rt;
+        this.intl = intl;
+        this.hooks = hooks;
+    }
+    makeContext = (id, options) => {
+        if (!id)
+            throw new Error("must specify an id");
+        const i18nKey = options?.i18nCustomKey ?? id;
+        const namespace = `action.${i18nKey}`;
+        // must remain stable through out single call
+        const action = this.intl.formatMessage({
+            id: namespace,
+            defaultMessage: id
+        }, { ...options?.state, _isLabel: false });
+        const label = this.intl.formatMessage({
+            id: namespace,
+            defaultMessage: id
+        }, { ...options?.state, _isLabel: true });
+        const context = CommandContext.of({
+            ...makeBaseInfo(id, options),
+            action,
+            label,
+            state: options?.state
+        });
+        return context;
+    };
+    makeCommand = (id_, options, errorDef) => {
+        const id = typeof id_ === "string" ? id_ : id_.id;
+        const state = getStateValues(options);
+        return Object.assign((handler) => {
+            // we capture the definition stack here, so we can append it to later stack traces
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const localErrorDef = new Error();
+            Error.stackTraceLimit = limit;
+            if (!errorDef) {
+                errorDef = localErrorDef;
+            }
+            const key = `Commander.Command.${id}.state`;
+            const stateTag = Context.Service(key);
+            const makeContext_ = () => this.makeContext(id, { ...options, state: state?.value });
+            const initialContext = makeContext_();
+            const context = computed(() => makeContext_());
+            const action = computed(() => context.value.action);
+            const label = computed(() => context.value.label);
+            const errorReporter = (self) => self.pipe(Effect.tapCause(Effect.fnUntraced(function* (cause) {
+                if (Cause.hasInterruptsOnly(cause)) {
+                    console.info(`Interrupted while trying to ${id}`);
+                    return;
+                }
+                const fail = Cause.findErrorOption(cause);
+                if (Option.isSome(fail)) {
+                    // if (fail.value._tag === "SuppressErrors") {
+                    //   console.info(
+                    //     `Suppressed error trying to ${action}`,
+                    //     fail.value,
+                    //   )
+                    //   return
+                    // }
+                    const message = `Failure trying to ${id}`;
+                    yield* reportMessage(message, {
+                        action: id,
+                        error: fail.value
+                    });
+                    return;
+                }
+                const context = yield* CommandContext;
+                const extra = {
+                    action: context.action,
+                    message: `Unexpected Error trying to ${id}`
+                };
+                yield* reportRuntimeError(cause, extra);
+            }, Effect.uninterruptible)));
+            const currentState = Effect.sync(() => state.value);
+            const theHandler = flow(handler, errorReporter, 
+            // all must be within the Effect.fn to fit within the Span
+            Effect.provideServiceEffect(stateTag, currentState), Effect.provideServiceEffect(CommandContext, Effect.sync(() => makeContext_())));
+            const waitId = options?.waitKey ? options.waitKey(id) : undefined;
+            const blockId = options?.blockKey ? options.blockKey(id) : undefined;
+            const [result, exec_] = asResult(theHandler);
+            const exec = Effect
+                .fnUntraced(function* (...args) {
+                if (waitId !== undefined)
+                    registerWait(waitId);
+                if (blockId !== undefined && blockId !== waitId) {
+                    registerWait(blockId);
+                }
+                return yield* exec_(...args);
+            }, Effect.onExit(() => Effect.sync(() => {
+                if (waitId !== undefined)
+                    unregisterWait(waitId);
+                if (blockId !== undefined && blockId !== waitId) {
+                    unregisterWait(blockId);
+                }
+            })));
+            const waiting = waitId !== undefined
+                ? computed(() => result.value.waiting || (waitState.value[waitId] ?? 0) > 0)
+                : computed(() => result.value.waiting);
+            const blocked = blockId !== undefined
+                ? computed(() => waiting.value || (waitState.value[blockId] ?? 0) > 0)
+                : computed(() => waiting.value);
+            const computeAllowed = options?.allowed;
+            const allowed = computeAllowed ? computed(() => computeAllowed(id, state)) : true;
+            const rt = Effect.services().pipe(Effect.provide(this.hooks)).pipe(Effect.runSyncWith(this.rt));
+            const runFork = Effect.runForkWith(rt);
+            const handle = Object.assign((arg) => {
+                // we capture the call site stack here
+                const limit = Error.stackTraceLimit;
+                Error.stackTraceLimit = 2;
+                const errorCall = new Error();
+                Error.stackTraceLimit = limit;
+                let cache = false;
+                const captureStackTrace = () => {
+                    // in case of an error, we want to append the definition stack to the call site stack,
+                    // so we can see where the handler was defined too
+                    if (cache !== false) {
+                        return cache;
+                    }
+                    if (errorCall.stack) {
+                        const stackDef = errorDef.stack.trim().split("\n");
+                        const stackCall = errorCall.stack.trim().split("\n");
+                        let endStackDef = stackDef.slice(2).join("\n").trim();
+                        if (!endStackDef.includes(`(`)) {
+                            endStackDef = endStackDef.replace(/at (.*)/, "at ($1)");
+                        }
+                        let endStackCall = stackCall.slice(2).join("\n").trim();
+                        if (!endStackCall.includes(`(`)) {
+                            endStackCall = endStackCall.replace(/at (.*)/, "at ($1)");
+                        }
+                        cache = `${endStackDef}\n${endStackCall}`;
+                        return cache;
+                    }
+                };
+                const command = currentState.pipe(Effect.flatMap((state) => Effect.withSpan(exec(arg, { ...context.value, state }), id, {
+                    captureStackTrace,
+                    attributes: {
+                        input: arg,
+                        state,
+                        action: initialContext.action,
+                        label: initialContext.label,
+                        id: initialContext.id,
+                        i18nKey: initialContext.i18nKey
+                    }
+                })));
+                return runFork(command);
+            }, { action, label });
+            return reactive({
+                /** static */
+                id,
+                /** the base i18n key, based on id by default. static */
+                i18nKey: initialContext.i18nKey,
+                /** the `action.` namespace based on i18nKey.. static */
+                namespace: initialContext.namespace,
+                /** easy generate namespaced 18n keys, based on namespace. static */
+                namespaced: initialContext.namespaced,
+                /** reactive */
+                result,
+                /** reactive */
+                waiting,
+                /** reactive */
+                blocked,
+                /** reactive */
+                allowed,
+                /** reactive */
+                action,
+                /** reactive */
+                label,
+                /** reactive */
+                state,
+                handle
+            });
+        }, { id });
+    };
+    // /** @experimental */
+    // takeOver:
+    //   <Args extends any[], A, E, R, const Id extends string>(command: Commander.CommandOut<Args, A, E, R, Id,I18nKey>) =>
+    //   (...args: Args) => {
+    //     // we capture the call site stack here
+    //     const limit = Error.stackTraceLimit
+    //     Error.stackTraceLimit = 2
+    //     const errorCall = new Error()
+    //     const localErrorDef = new Error()
+    //     Error.stackTraceLimit = limit
+    //     // TODO
+    //     const errorDef = localErrorDef
+    //     let cache: false | string = false
+    //     const captureStackTrace = () => {
+    //       // in case of an error, we want to append the definition stack to the call site stack,
+    //       // so we can see where the handler was defined too
+    //       if (cache !== false) {
+    //         return cache
+    //       }
+    //       if (errorCall.stack) {
+    //         const stackDef = errorDef.stack!.trim().split("\n")
+    //         const stackCall = errorCall.stack.trim().split("\n")
+    //         let endStackDef = stackDef.slice(2).join("\n").trim()
+    //         if (!endStackDef.includes(`(`)) {
+    //           endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
+    //         }
+    //         let endStackCall = stackCall.slice(2).join("\n").trim()
+    //         if (!endStackCall.includes(`(`)) {
+    //           endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
+    //         }
+    //         cache = `${endStackDef}\n${endStackCall}`
+    //         return cache
+    //       }
+    //     }
+    //     return Effect.gen(function*() {
+    //       const ctx = yield* CommandContext
+    //       ctx.action = command.action
+    //       return yield* command.exec(...args).pipe(
+    //         Effect.flatten,
+    //         Effect.withSpan(
+    //           command.action,
+    //           { captureStackTrace }
+    //         )
+    //       )
+    //     })
+    //   },
+    /**
+     * Define a Command for handling user actions with built-in error reporting and state management.
+     *
+     * @param id The internal identifier for the action. Used as a tracing span and to lookup
+     *                   the user-facing name via internationalization (`action.${id}`).
+     * @param options Optional configuration for internationalization and state.
+     * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
+     * @param options.state Optional reactive state object (or function returning one) that is
+     *                     made available to the command effects and can be used for i18n interpolation.
+     *                     The state is captured at the start of each command execution and remains stable throughout.
+     * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
+     *          Built-in error reporting handles failures automatically.
+     *
+     * **Effect Context**: Effects have access to the `CommandContext` service, which provides
+     * the user-facing action name.
+     *
+     * **Returned Properties**:
+     * - `action`: User-facing action name from intl messages (useful for button labels)
+     * - `result`: The command result state
+     * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
+     * - `handle`: Function to execute the command
+     * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
+     * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
+     *
+     * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
+     * the `result` inline for custom UI feedback.
+     */
+    fn = (id, options) => Object.assign((fn, ...combinators) => {
+        // we capture the definition stack here, so we can append it to later stack traces
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 2;
+        const errorDef = new Error();
+        Error.stackTraceLimit = limit;
+        return this.makeCommand(id, options, errorDef)(Effect.fnUntraced(
+        // fnUntraced only supports generators as first arg, so we convert to generator if needed
+        isGeneratorFunction(fn) ? fn : function* (...args) {
+            return yield* fn(...args);
+        }, ...combinators));
+    }, makeBaseInfo(typeof id === "string" ? id : id.id, options), {
+        state: Context.Service(`Commander.Command.${typeof id === "string" ? id : id.id}.state`)
+    });
+    /** @deprecated */
+    alt2 = (_id, options) => {
+        const isObject = Predicate.isObjectKeyword(_id);
+        const id = isObject ? _id.id : _id;
+        const baseInfo = makeBaseInfo(id, options);
+        const idCmd = this.makeCommand(id, options);
+        // TODO: implement proper tracing stack
+        return Object.assign((cb) => idCmd(cb(Object.assign((fn, ...combinators) => Effect.fnUntraced(
+        // fnUntraced only supports generators as first arg, so we convert to generator if needed
+        isGeneratorFunction(fn) ? fn : function* (...args) {
+            return yield* fn(...args);
+        }, ...combinators), baseInfo, isObject
+            ? { mutate: "mutate" in _id ? _id.mutate : typeof _id === "function" ? _id : undefined }
+            : {}))), baseInfo);
+    };
+    alt = this.makeCommand;
+    /**
+     * Define a Command for handling user actions with built-in error reporting and state management.
+     *
+     * @param mutation The mutation function to take the identifier and initial handler from. Used as a tracing span and to lookup
+     *                   the user-facing name via internationalization (`action.${id}`).
+     * @param options Optional configuration for internationalization and state.
+     * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
+     * @param options.state Optional reactive state object (or function returning one) that is
+     *                     made available to the command effects and can be used for i18n interpolation.
+     *                     The state is captured at the start of each command execution and remains stable throughout.
+     * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
+     *          Built-in error reporting handles failures automatically.
+     *
+     * **Effect Context**: Effects have access to the `CommandContext` service, which provides
+     * the user-facing action name.
+     *
+     * **Returned Properties**:
+     * - `action`: User-facing action name from intl messages (useful for button labels)
+     * - `result`: The command result state
+     * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
+     * - `handle`: Function to execute the command
+     * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
+     * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
+     *
+     * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
+     * the `result` inline for custom UI feedback.
+     */
+    wrap = (mutation, options) => Object.assign((...combinators) => {
+        // we capture the definition stack here, so we can append it to later stack traces
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 2;
+        const errorDef = new Error();
+        Error.stackTraceLimit = limit;
+        const mutate = "mutate" in mutation ? mutation.mutate : mutation;
+        return this.makeCommand(mutation.id, options, errorDef)(Effect.fnUntraced(
+        // fnUntraced only supports generators as first arg, so we convert to generator if needed
+        isGeneratorFunction(mutate) ? mutate : function* (arg) {
+            return yield* mutate(arg);
+        }, ...combinators));
+    }, makeBaseInfo(mutation.id, options), {
+        state: Context.Service(`Commander.Command.${mutation.id}.state`)
+    });
+}
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class Commander extends Context.Service()("Commander", {
+    make: Effect.gen(function* () {
+        const i18n = yield* I18n;
+        return (rt, rtHooks) => new CommanderImpl(rt, i18n, rtHooks);
+    })
+}) {
+    static DefaultWithoutDependencies = Layer.effect(this, this.make);
+    static Default = this.DefaultWithoutDependencies;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commander.js","sourceRoot":"","sources":["../src/commander.ts"],"names":[],"mappings":"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"}

package/dist/{experimental/confirm.d.ts → confirm.d.ts}

@@ -1,6 +1,6 @@
-import { Effect, Layer, ServiceMap } from "effect-app";
+import { Context, Effect, Layer } from "effect-app";
 import { I18n } from "./intl.js";
-declare const Confirm_base: ServiceMap.ServiceClass<Confirm, "Confirm", {
+declare const Confirm_base: Context.ServiceClass<Confirm, "Confirm", {
     confirm: (message?: string) => Effect.Effect<boolean, never, never>;
     confirmOrInterrupt: (message?: string) => Effect.Effect<void, never, never>;
 }> & {

package/dist/confirm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirm.d.ts","sourceRoot":"","sources":["../src/confirm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;;;;;;;;;;AAGhC,qBAAa,OAAQ,SAAQ,YAe3B;IACA,MAAM,CAAC,QAAQ,CAAC,0BAA0B,oCAAgC;IAC1E,MAAM,CAAC,QAAQ,CAAC,OAAO,oCAAkC;IAEzD,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM;IAM/B,MAAM,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,MAAM;CAM3C"}

package/dist/confirm.js

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer } from "effect-app";
+import { I18n } from "./intl.js";
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class Confirm extends Context.Service()("Confirm", {
+    make: Effect.gen(function* () {
+        const { intl } = yield* I18n;
+        const getDefaultMessage = () => intl.formatMessage({ id: "confirm.default", defaultMessage: "Sind sie Sicher?" });
+        const confirm = (message = getDefaultMessage()) => Effect.sync(() => window.confirm(message));
+        const confirmOrInterrupt = (message = getDefaultMessage()) => confirm(message).pipe(Effect.flatMap((result) => (result ? Effect.void : Effect.interrupt)));
+        return { confirm, confirmOrInterrupt };
+    })
+}) {
+    static DefaultWithoutDependencies = Layer.effect(this, this.make);
+    static Default = this.DefaultWithoutDependencies;
+    static confirm(message) {
+        return Effect.gen(function* () {
+            const c = yield* Confirm;
+            return yield* c.confirm(message);
+        });
+    }
+    static confirmOrInterrupt(message) {
+        return Effect.gen(function* () {
+            const c = yield* Confirm;
+            return yield* c.confirmOrInterrupt(message);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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