@primafuture/contrib-kit-react 1.0.0

package/dist/internal/outlet-membership-boundary.js

@@ -0,0 +1,710 @@
+import * as react from "react";
+import * as managedLazyGeneration from "./managed-lazy-generation.js";
+import * as outletErrorPipeline from "./outlet-error-pipeline.js";
+import * as outletInput from "./outlet-input.js";
+import * as outletReporterBoundary from "./outlet-reporter-boundary.js";
+import * as reactAdapterDiagnostics from "../react-adapter-diagnostics.js";
+import * as reactAdapterErrorRuntime from "../react-adapter-error.js";
+/** Vytvoří nový render-pure opaque retry generation token. */
+function createRetryGenerationToken() {
+    return Object.freeze({});
+}
+/** Vytvoří počáteční nebo identity-reset state před renderem nové membership. */
+function createMembershipBoundaryState(props, subtreeGeneration = 0) {
+    const seed = props.membership.seed;
+    return {
+        capturedCause: undefined,
+        escalationCause: undefined,
+        errorAttemptToken: undefined,
+        hasCapturedCause: false,
+        lazyComponent: undefined,
+        lazyLoad: seed.kind === "loading" ? seed.load : undefined,
+        lazyStatus: seed.kind === "loading" ? "loading" : "inactive",
+        rawRegistry: props.rawRegistry,
+        registrationId: props.membership.seed.registrationId,
+        membershipToken: props.membership.token,
+        mode: "rendering",
+        primaryError: undefined,
+        retry: undefined,
+        retryGeneration: 0,
+        retryToken: createRetryGenerationToken(),
+        subtreeGeneration,
+    };
+}
+/** Renderuje ready nebo loading větev uvnitř package class boundary. */
+function OutletMembershipRenderer(props) {
+    const seed = props.seed;
+    if (seed.kind === "loading") {
+        if (props.input.renderLoading === undefined) {
+            return null;
+        }
+        const rendered = outletInput.callCapturedOutletCallback(props.input.renderLoading, seed.renderState);
+        return react.createElement(react.Fragment, null, rendered);
+    }
+    if (props.input.renderContribution !== undefined) {
+        const rendered = outletInput.callCapturedOutletCallback(props.input.renderContribution, seed.renderState);
+        return react.createElement(react.Fragment, null, rendered);
+    }
+    return react.createElement(seed.renderState.component, seed.renderState.componentProps);
+}
+/** Volá contribution fallback uvnitř samostatné reporter class boundary. */
+function OutletContributionFallbackRenderer(props) {
+    const state = Object.freeze({
+        ...props.seed.renderState,
+        error: props.error,
+        retry: props.retry,
+    });
+    const rendered = outletInput.callCapturedOutletCallback(props.renderContributionError, state);
+    return react.createElement(react.Fragment, null, rendered);
+}
+/** Vrátí exact synthetic cause, nebo původní classifier cause ReactAdapterErroru. */
+function resolveProjectedFailureCause(error) {
+    return Object.hasOwn(error, "cause") ? error.cause : error;
+}
+/** Odvodí public phase z bezpečných details, jinak použije render. */
+function resolveProjectedFailurePhase(error) {
+    const phase = error.details.phase;
+    return phase === "configuration"
+        || phase === "resolve"
+        || phase === "load"
+        || phase === "render"
+        || phase === "customRender"
+        || phase === "fallback"
+        || phase === "policy"
+        || phase === "projection"
+        || phase === "callback"
+        || phase === "lifecycle"
+        ? phase
+        : "render";
+}
+/** Projektuje pouze bezpečnou identitu current managed-lazy contribution. */
+function createManagedLazyContributionMetadata(seed) {
+    const contribution = seed.renderState.contribution;
+    return Object.freeze({
+        registrationId: seed.registrationId,
+        contributionId: contribution.contributionId,
+        ...(contribution.contributorId === undefined
+            ? {}
+            : { contributorId: contribution.contributorId }),
+        ...(contribution.label === undefined ? {} : { label: contribution.label }),
+        ...(contribution.localName === undefined
+            ? {}
+            : { localName: contribution.localName }),
+    });
+}
+/** Ověří active live registry bez propouštění hostile state accessoru. */
+function isManagedLazyRegistryActive(rawRegistry) {
+    try {
+        return Reflect.get(rawRegistry, "state", rawRegistry) === "active";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Interní class error boundary jedné exact Core membership.
+ */
+export class OutletMembershipBoundary extends react.Component {
+    /** Current identity/generation/presentation state. */
+    state;
+    /** Current commit-owned boundary ID lease. */
+    #boundaryLease;
+    /** Membership token, pro který current lease vznikla. */
+    #boundaryLeaseToken;
+    /** Current mutable primary attempt authority. */
+    #primaryAttempt;
+    /** Poslední retry generation již doručená onRetry callbacku. */
+    #reportedRetryGeneration = 0;
+    /** Current resource-free nebo started managed-lazy operation. */
+    #lazyOperation;
+    /** Membership token owning current lazy operation. */
+    #lazyOperationMembershipToken;
+    /** Retry token owning current lazy operation. */
+    #lazyOperationRetryToken;
+    /** Zabraňuje novému attemptu během loading-error invalidace a abortu. */
+    #lazyStartBarrier = 0;
+    /** Terminální guard skutečného unmountu i Strict grace mezery. */
+    #unmounted = false;
+    /** Vytvoří resource-free initial state a operation bez loader side effectu. */
+    constructor(props) {
+        super(props);
+        this.state = createMembershipBoundaryState(props);
+        this.#synchronizeLazyOperation();
+    }
+    /** Capture descendant error bez sinku, callbacku, policy nebo Core callu. */
+    static getDerivedStateFromError(cause) {
+        return {
+            capturedCause: cause,
+            errorAttemptToken: Object.freeze({}),
+            hasCapturedCause: true,
+            mode: "captured",
+            primaryError: undefined,
+            retry: undefined,
+        };
+    }
+    /** Resetuje celý boundary state před renderem jiné identity tuple. */
+    static getDerivedStateFromProps(props, state) {
+        return props.rawRegistry === state.rawRegistry
+            && props.membership.seed.registrationId === state.registrationId
+            && props.membership.token === state.membershipToken
+            ? null
+            : createMembershipBoundaryState(props, state.subtreeGeneration + 1);
+    }
+    /** Commit acquire boundary identity a případné synthetic seed failure. */
+    componentDidMount() {
+        this.#unmounted = false;
+        this.#synchronizeBoundaryLease();
+        this.#reactivatePreservedPrimaryAttempt();
+        const operationChanged = this.#synchronizeLazyOperation();
+        this.#commitProjectedFailure();
+        if (operationChanged) {
+            this.forceUpdate();
+        }
+    }
+    /** Synchronizuje identity switch, committed retry event a current seed failure. */
+    componentDidUpdate(_previousProps, previousState) {
+        if (previousState.membershipToken !== this.state.membershipToken
+            || previousState.rawRegistry !== this.state.rawRegistry
+            || previousState.registrationId !== this.state.registrationId) {
+            this.#invalidatePrimaryAttempt();
+            const dispatchAbort = this.#invalidateLazyOperation();
+            dispatchAbort();
+            this.#reportedRetryGeneration = 0;
+        }
+        this.#synchronizeBoundaryLease();
+        this.#reactivatePreservedPrimaryAttempt();
+        const operationChanged = this.#synchronizeLazyOperation();
+        if (previousState.retryGeneration !== this.state.retryGeneration) {
+            this.#reportCommittedRetry();
+        }
+        this.#commitProjectedFailure();
+        if (operationChanged) {
+            this.forceUpdate();
+        }
+    }
+    /** Commit point primary render chyby spustí pipeline právě jednou. */
+    componentDidCatch(cause, info) {
+        const attemptToken = this.state.errorAttemptToken;
+        if (!this.state.hasCapturedCause || attemptToken === undefined) {
+            return;
+        }
+        const phase = this.#readRenderFailurePhase();
+        const reactComponentStack = outletErrorPipeline.normalizeReactComponentStack(info.componentStack);
+        if (this.state.lazyStatus !== "loading") {
+            this.#commitPrimaryFailure(attemptToken, "REACT_RENDER_FAILED", phase, cause, reactComponentStack);
+            return;
+        }
+        const dispatchAbort = this.#invalidateLazyOperation();
+        this.#lazyStartBarrier += 1;
+        try {
+            this.#commitPrimaryFailure(attemptToken, "REACT_RENDER_FAILED", phase, cause, reactComponentStack);
+        }
+        finally {
+            try {
+                dispatchAbort();
+            }
+            finally {
+                this.#lazyStartBarrier -= 1;
+            }
+        }
+    }
+    /** Synchronous invalidace před release commit-owned boundary lease. */
+    componentWillUnmount() {
+        this.#unmounted = true;
+        this.#invalidatePrimaryAttempt();
+        this.#releaseBoundaryLease();
+    }
+    /** Renderuje current membership, provisional null, fallback nebo exact escalation. */
+    render() {
+        if (this.state.mode === "escalating") {
+            throw this.state.escalationCause;
+        }
+        if (this.state.mode === "captured" || this.state.mode === "hidden") {
+            return null;
+        }
+        if (this.state.mode === "fallback") {
+            return this.#renderFallback();
+        }
+        const seed = this.props.membership.seed;
+        if (seed.kind === "failed") {
+            return null;
+        }
+        if (seed.kind === "loading" && this.state.lazyStatus === "failed") {
+            return null;
+        }
+        const rendered = react.createElement(OutletMembershipRenderer, {
+            key: `${this.state.subtreeGeneration}:${this.state.retryGeneration}`,
+            input: this.props.input,
+            seed: this.#createCurrentRenderSeed(seed),
+        });
+        const operation = this.#readCurrentLazyOperation();
+        return operation === undefined
+            ? rendered
+            : react.createElement(managedLazyGeneration.ManagedLazyCommitLease, { children: rendered, operation });
+    }
+    /**
+     * Převede loaded lazy componentu na ready seed s nejnovějším render inputem.
+     */
+    #createCurrentRenderSeed(seed) {
+        if (seed.kind !== "loading" || this.state.lazyStatus !== "ready") {
+            return seed;
+        }
+        const component = this.state.lazyComponent;
+        const componentProps = Object.freeze({
+            context: seed.renderState.context,
+            contribution: seed.renderState.contribution,
+            placement: seed.renderState.placement,
+        });
+        return Object.freeze({
+            kind: "ready",
+            registrationId: seed.registrationId,
+            renderState: Object.freeze({
+                ...seed.renderState,
+                component,
+                componentProps,
+            }),
+        });
+    }
+    /** Vrátí operation pouze pro exact renderovanou loading generation. */
+    #readCurrentLazyOperation() {
+        return this.state.lazyStatus === "loading"
+            && this.#lazyStartBarrier === 0
+            && this.#lazyOperationMembershipToken === this.state.membershipToken
+            && this.#lazyOperationRetryToken === this.state.retryToken
+            ? this.#lazyOperation
+            : undefined;
+    }
+    /**
+     * Vytvoří nejvýše jednu resource-free operation pro exact retry generation.
+     */
+    #synchronizeLazyOperation() {
+        const load = this.state.lazyLoad;
+        const seed = this.props.membership.seed;
+        const outletLease = this.props.outletLease;
+        if (outletLease === undefined
+            || this.state.lazyStatus !== "loading" || load === undefined
+            || seed.kind !== "loading" || this.#lazyStartBarrier > 0) {
+            return false;
+        }
+        if (this.#lazyOperation !== undefined
+            && this.#lazyOperationMembershipToken === this.state.membershipToken
+            && this.#lazyOperationRetryToken === this.state.retryToken) {
+            this.#lazyOperation.requestStartRecheck();
+            return false;
+        }
+        const dispatchPreviousAbort = this.#invalidateLazyOperation();
+        dispatchPreviousAbort();
+        const membershipToken = this.state.membershipToken;
+        const retryToken = this.state.retryToken;
+        const retryGeneration = this.state.retryGeneration;
+        const scope = this.props.scope;
+        const scopeGeneration = this.props.scopeGeneration;
+        const rawRegistry = this.props.rawRegistry;
+        const configuration = this.props.input.configuration;
+        const contribution = createManagedLazyContributionMetadata(seed);
+        const point = reactAdapterDiagnostics.createPointMetadata(seed.renderState.point);
+        let diagnosticChannel;
+        let lifecycleFailureReported = false;
+        let operation;
+        /** Otestuje current operation včetně committed outlet a scope lease. */
+        function isCurrentOperation(boundary) {
+            return boundary.#lazyOperation === operation
+                && boundary.state.lazyStatus === "loading"
+                && boundary.#lazyStartBarrier === 0
+                && boundary.#isGenerationCurrent(membershipToken, retryToken);
+        }
+        operation = new managedLazyGeneration.ManagedLazyGenerationOperation(retryGeneration, load, Object.freeze({
+            isCurrent: () => isCurrentOperation(this),
+            onResolved: (component) => {
+                this.#publishLazyComponent(operation, membershipToken, retryToken, component);
+            },
+            onFailed: (failure) => {
+                this.#publishLazyFailure(operation, membershipToken, retryToken, failure);
+            },
+            onLate: (outcome) => {
+                this.#reportLateLazyResult(operation, diagnosticChannel, outcome);
+            },
+            onLifecycleFailure: (cause) => {
+                if (lifecycleFailureReported) {
+                    return;
+                }
+                lifecycleFailureReported = true;
+                this.#reportLazyLifecycleFailure(diagnosticChannel, cause);
+            },
+            registerInvalidation: (invalidate) => {
+                const boundaryLease = this.#boundaryLease;
+                if (boundaryLease !== undefined
+                    && boundaryLease.isCurrent()
+                    && outletLease.isCurrent()
+                    && scope.isGenerationActive(scopeGeneration)) {
+                    diagnosticChannel = Object.freeze({
+                        boundaryId: boundaryLease.id,
+                        configuration,
+                        contribution,
+                        outletLease,
+                        ...(point === undefined ? {} : { point }),
+                        rawRegistry,
+                        retryGeneration,
+                        scope,
+                        scopeGeneration,
+                    });
+                }
+                return scope.registerEpochAbortable(scopeGeneration, () => {
+                    if (this.#lazyOperation === operation) {
+                        this.#lazyOperation = undefined;
+                        this.#lazyOperationMembershipToken = undefined;
+                        this.#lazyOperationRetryToken = undefined;
+                    }
+                    return invalidate();
+                });
+            },
+        }));
+        this.#lazyOperation = operation;
+        this.#lazyOperationMembershipToken = membershipToken;
+        this.#lazyOperationRetryToken = retryToken;
+        return true;
+    }
+    /** Doručí jeden safe late-result event pouze do stále vlastněného channelu. */
+    #reportLateLazyResult(operation, channel, outcome) {
+        if (channel === undefined
+            || !channel.scope.isGenerationActive(channel.scopeGeneration)
+            || !channel.outletLease.isCurrent()
+            || !isManagedLazyRegistryActive(channel.rawRegistry)
+            || !channel.scope.claimDiagnosticAttempt(operation.loadAttemptToken)) {
+            return;
+        }
+        reactAdapterDiagnostics.reportReactAdapterDiagnostic(reactAdapterDiagnostics.createLateLazyResultDiagnostic({
+            boundaryId: channel.boundaryId,
+            contribution: channel.contribution,
+            outcome,
+            outletId: channel.outletLease.id,
+            ...(channel.point === undefined ? {} : { point: channel.point }),
+            retryGeneration: channel.retryGeneration,
+        }), channel.configuration);
+    }
+    /** Publikuje abort/unsubscribe failure bez UI, callback nebo policy autority. */
+    #reportLazyLifecycleFailure(channel, cause) {
+        if (channel === undefined
+            || !channel.scope.isGenerationActive(channel.scopeGeneration)
+            || !channel.outletLease.isCurrent()
+            || !isManagedLazyRegistryActive(channel.rawRegistry)) {
+            return;
+        }
+        const error = reactAdapterDiagnostics.createReactAdapterErrorEvent({
+            boundaryId: channel.boundaryId,
+            code: "REACT_CALLBACK_FAILED",
+            cause,
+            contribution: channel.contribution,
+            outletId: channel.outletLease.id,
+            phase: "lifecycle",
+            ...(channel.point === undefined ? {} : { point: channel.point }),
+            retryGeneration: channel.retryGeneration,
+        });
+        reactAdapterDiagnostics.reportReactAdapterDiagnostic(reactAdapterDiagnostics.createErrorDiagnostic(error), channel.configuration);
+    }
+    /** Publikuje validní componentu pouze do exact current loading generation. */
+    #publishLazyComponent(operation, membershipToken, retryToken, component) {
+        if (this.#lazyOperation !== operation
+            || this.state.lazyStatus !== "loading"
+            || !this.#isGenerationCurrent(membershipToken, retryToken)) {
+            return;
+        }
+        this.setState({ lazyComponent: component, lazyStatus: "ready" });
+    }
+    /** Převede current lazy failure do committed contribution error pipeline. */
+    #publishLazyFailure(operation, membershipToken, retryToken, failure) {
+        if (this.#lazyOperation !== operation
+            || this.state.lazyStatus !== "loading"
+            || !this.#isGenerationCurrent(membershipToken, retryToken)) {
+            return;
+        }
+        const cause = Object.hasOwn(failure, "cause")
+            ? failure.cause
+            : new reactAdapterErrorRuntime.ReactAdapterError("REACT_POINT_IMPLEMENTATION_INVALID", "The managed React contribution loader returned a non-component value.", { details: { field: "loader.result", phase: "load" } });
+        const errorAttemptToken = Object.freeze({});
+        this.setState({ lazyComponent: undefined, lazyStatus: "failed" }, 
+        /** Pipeline smí začít až po commitu failed presentation. */
+        () => {
+            if (this.#lazyOperation !== operation
+                || this.state.lazyStatus !== "failed"
+                || !this.#isGenerationCurrent(membershipToken, retryToken)) {
+                return;
+            }
+            this.#commitPrimaryFailure(errorAttemptToken, failure.code, "load", cause, undefined);
+        });
+    }
+    /** Zneplatní current lazy operation a vrátí oddělený abort dispatch. */
+    #invalidateLazyOperation() {
+        const operation = this.#lazyOperation;
+        this.#lazyOperation = undefined;
+        this.#lazyOperationMembershipToken = undefined;
+        this.#lazyOperationRetryToken = undefined;
+        return operation?.invalidate() ?? managedLazyGeneration.skipManagedLazyAbortDispatch;
+    }
+    /** Ověří a případně obnoví commit lease current membership tokenu. */
+    #synchronizeBoundaryLease() {
+        const membershipToken = this.state.membershipToken;
+        if (this.props.outletLease?.isCurrent() !== true) {
+            this.#releaseBoundaryLease();
+            return;
+        }
+        if (this.#boundaryLeaseToken === membershipToken
+            && this.#boundaryLease?.isCurrent() === true) {
+            return;
+        }
+        this.#releaseBoundaryLease();
+        this.#boundaryLease = this.props.scope.acquireCommitLease(this.props.scopeGeneration, "boundary", membershipToken);
+        this.#boundaryLeaseToken = membershipToken;
+    }
+    /** Idempotentně release boundary lease bez změny Core registry. */
+    #releaseBoundaryLease() {
+        this.#boundaryLease?.release();
+        this.#boundaryLease = undefined;
+        this.#boundaryLeaseToken = undefined;
+    }
+    /** Ověří current committed membership, retry generation, outlet i scope lease. */
+    #isGenerationCurrent(membershipToken, retryToken) {
+        return !this.#unmounted
+            && this.state.membershipToken === membershipToken
+            && this.state.retryToken === retryToken
+            && this.props.rawRegistry === this.state.rawRegistry
+            && this.props.membership.token === membershipToken
+            && this.props.membership.seed.registrationId === this.state.registrationId
+            && this.#boundaryLeaseToken === membershipToken
+            && this.#boundaryLease?.isCurrent() === true
+            && this.props.outletLease?.isCurrent() === true;
+    }
+    /** Ověří celý primary attempt včetně sync retry invalidace. */
+    #isPrimaryAttemptCurrent(attempt) {
+        return attempt.authoritative
+            && this.#primaryAttempt === attempt
+            && this.#boundaryLease === attempt.boundaryLease
+            && attempt.boundaryLease.isCurrent()
+            && this.#isGenerationCurrent(attempt.membershipToken, attempt.retryToken);
+    }
+    /** Vytvoří retry capability svázanou s current boundary lease a UI generation. */
+    #createPrimaryAttempt(errorAttemptToken, boundaryLease) {
+        const attempt = {
+            authoritative: true,
+            boundaryLease,
+            published: false,
+            errorAttemptToken,
+            membershipToken: this.state.membershipToken,
+            retry: () => { },
+            retryToken: this.state.retryToken,
+        };
+        const boundary = this;
+        /** Přijme právě první current retry call dané primary capability. */
+        function retry() {
+            boundary.#acceptRetry(attempt);
+        }
+        attempt.retry = Object.freeze(retry);
+        return attempt;
+    }
+    /** Zneplatní primary capability dříve než začne další lifecycle práce. */
+    #invalidatePrimaryAttempt() {
+        if (this.#primaryAttempt !== undefined) {
+            this.#primaryAttempt.authoritative = false;
+            this.#primaryAttempt = undefined;
+        }
+    }
+    /**
+     * Naváže zachovanou failed presentation na novou Activity epochu bez replaye pipeline.
+     */
+    #reactivatePreservedPrimaryAttempt() {
+        if (this.state.primaryError === undefined
+            || this.state.retry === undefined
+            || (this.state.mode !== "fallback" && this.state.mode !== "hidden")) {
+            return;
+        }
+        const currentAttempt = this.#primaryAttempt;
+        if (currentAttempt !== undefined && this.#isPrimaryAttemptCurrent(currentAttempt)) {
+            return;
+        }
+        this.#invalidatePrimaryAttempt();
+        const boundaryLease = this.#boundaryLease;
+        if (boundaryLease === undefined
+            || !this.#isGenerationCurrent(this.state.membershipToken, this.state.retryToken)) {
+            return;
+        }
+        const attempt = this.#createPrimaryAttempt(Object.freeze({}), boundaryLease);
+        attempt.published = true;
+        this.#primaryAttempt = attempt;
+        this.setState({ retry: attempt.retry });
+    }
+    /** Převede current failed projection na committed primary pipeline. */
+    #commitProjectedFailure() {
+        const seed = this.props.membership.seed;
+        if (seed.kind !== "failed" || this.state.mode !== "rendering") {
+            return;
+        }
+        this.#commitPrimaryFailure(Object.freeze({}), seed.error.code, resolveProjectedFailurePhase(seed.error), resolveProjectedFailureCause(seed.error), undefined);
+    }
+    /** Spustí at-most-once pipeline jednoho exact membership/error attemptu. */
+    #commitPrimaryFailure(errorAttemptToken, code, phase, cause, reactComponentStack) {
+        this.#synchronizeBoundaryLease();
+        const membershipToken = this.state.membershipToken;
+        const retryToken = this.state.retryToken;
+        if (!this.#isGenerationCurrent(membershipToken, retryToken)) {
+            return;
+        }
+        if (this.#primaryAttempt?.errorAttemptToken === errorAttemptToken) {
+            return;
+        }
+        this.#invalidatePrimaryAttempt();
+        const lease = this.#boundaryLease;
+        const outletLease = this.props.outletLease;
+        if (lease === undefined || outletLease === undefined) {
+            return;
+        }
+        const attempt = this.#createPrimaryAttempt(errorAttemptToken, lease);
+        this.#primaryAttempt = attempt;
+        if (!this.props.scope.claimDiagnosticAttempt(errorAttemptToken)) {
+            attempt.authoritative = false;
+            return;
+        }
+        attempt.published = true;
+        const seed = this.props.membership.seed;
+        const decision = outletErrorPipeline.runOutletPrimaryErrorPipeline({
+            boundaryId: lease.id,
+            code,
+            configuration: this.props.input.configuration,
+            context: seed.renderState.context,
+            contribution: seed.renderState.contribution,
+            cause,
+            hasFallback: this.props.input.renderContributionError !== undefined,
+            isolateErrors: this.props.input.isolateErrors,
+            isCurrent: () => this.#isPrimaryAttemptCurrent(attempt),
+            onError: this.props.input.onError,
+            outletId: outletLease.id,
+            phase,
+            point: seed.renderState.point,
+            ...(reactComponentStack === undefined ? {} : { reactComponentStack }),
+            registrationId: seed.registrationId,
+            retry: attempt.retry,
+            retryGeneration: this.state.retryGeneration,
+        });
+        if (decision.kind === "stale" || !this.#isPrimaryAttemptCurrent(attempt)) {
+            return;
+        }
+        if (decision.kind === "hide") {
+            this.setState({ mode: "hidden", primaryError: decision.error, retry: attempt.retry });
+            return;
+        }
+        if (decision.kind === "renderFallback") {
+            this.setState({
+                mode: "fallback",
+                primaryError: decision.error,
+                retry: attempt.retry,
+            });
+            return;
+        }
+        this.setState({
+            escalationCause: decision.cause,
+            mode: "escalating",
+            primaryError: decision.error,
+            retry: attempt.retry,
+        });
+    }
+    /** Sync accepted retry invaliduje starý attempt a naplánuje novou subtree generation. */
+    #acceptRetry(attempt) {
+        if (!this.#isPrimaryAttemptCurrent(attempt)) {
+            return;
+        }
+        attempt.authoritative = false;
+        this.#primaryAttempt = undefined;
+        const dispatchAbort = this.#invalidateLazyOperation();
+        dispatchAbort();
+        this.setState((state) => ({
+            capturedCause: undefined,
+            escalationCause: undefined,
+            errorAttemptToken: undefined,
+            hasCapturedCause: false,
+            lazyComponent: undefined,
+            lazyStatus: state.lazyLoad === undefined ? "inactive" : "loading",
+            mode: "rendering",
+            primaryError: undefined,
+            retry: undefined,
+            retryGeneration: state.retryGeneration + 1,
+            retryToken: createRetryGenerationToken(),
+        }));
+    }
+    /** Doručí onRetry až po commitu nové current generation. */
+    #reportCommittedRetry() {
+        if (this.state.retryGeneration <= this.#reportedRetryGeneration) {
+            return;
+        }
+        this.#reportedRetryGeneration = this.state.retryGeneration;
+        const lease = this.#boundaryLease;
+        const outletLease = this.props.outletLease;
+        const membershipToken = this.state.membershipToken;
+        const retryToken = this.state.retryToken;
+        if (lease === undefined
+            || outletLease === undefined
+            || !this.#isGenerationCurrent(membershipToken, retryToken)) {
+            return;
+        }
+        const seed = this.props.membership.seed;
+        outletErrorPipeline.dispatchOutletRetryCallback({
+            boundaryId: lease.id,
+            configuration: this.props.input.configuration,
+            context: seed.renderState.context,
+            contribution: seed.renderState.contribution,
+            isCurrent: () => this.#isGenerationCurrent(membershipToken, retryToken),
+            onRetry: this.props.input.onRetry,
+            outletId: outletLease.id,
+            point: seed.renderState.point,
+            registrationId: seed.registrationId,
+            retryGeneration: this.state.retryGeneration,
+        });
+    }
+    /** Odliší default render od custom ready/loading rendereru. */
+    #readRenderFailurePhase() {
+        if (this.props.membership.seed.kind === "loading"
+            && this.state.lazyStatus !== "ready") {
+            return this.props.input.renderLoading === undefined ? "render" : "customRender";
+        }
+        return this.props.input.renderContribution === undefined ? "render" : "customRender";
+    }
+    /** Renderuje current fallback pod sink-only reporter boundary. */
+    #renderFallback() {
+        const renderContributionError = this.props.input.renderContributionError;
+        const error = this.state.primaryError;
+        const retry = this.state.retry;
+        const lease = this.#boundaryLease;
+        const outletLease = this.props.outletLease;
+        if (renderContributionError === undefined
+            || error === undefined
+            || retry === undefined
+            || lease === undefined
+            || outletLease === undefined) {
+            return null;
+        }
+        const seed = this.props.membership.seed;
+        const membershipToken = this.state.membershipToken;
+        const retryToken = this.state.retryToken;
+        const reporterInput = {
+            boundaryId: lease.id,
+            configuration: this.props.input.configuration,
+            context: seed.renderState.context,
+            contribution: seed.renderState.contribution,
+            isCurrent: () => this.#isGenerationCurrent(membershipToken, retryToken),
+            outletId: outletLease.id,
+            point: seed.renderState.point,
+            registrationId: seed.registrationId,
+            retryGeneration: this.state.retryGeneration,
+        };
+        const children = react.createElement(OutletContributionFallbackRenderer, {
+            error,
+            renderContributionError,
+            retry,
+            seed,
+        });
+        return react.createElement(outletReporterBoundary.OutletReporterBoundary, {
+            children,
+            errorInput: reporterInput,
+            generationToken: retryToken,
+        });
+    }
+}
+//# sourceMappingURL=outlet-membership-boundary.js.map