@gooddata/sdk-ui-ext 11.43.0-alpha.3 → 11.43.0-alpha.5

package/esm/share/useLabelScope.d.ts

@@ -1,6 +1,4 @@
-import { type MutableRefObject } from "react";
 import { type IObjectPermissionsObject } from "@gooddata/sdk-backend-spi";
-import type { IObjectAccessList } from "@gooddata/sdk-model";
 import { type LabelScopePrincipal } from "./objectShareController.helpers.js";
 import type { IObjectShareLabel } from "./types.js";
 /**
@@ -30,11 +28,6 @@ export interface ILabelScope {
     /** Per-grantee label scope: grantee id → label ids in scope (primary always in). */
     selectedLabelIdsByGrantee: Record<string, string[]>;
     setSelectedLabelIdsByGrantee: React.Dispatch<React.SetStateAction<Record<string, string[]>>>;
-    /**
-     * Grantee ids whose scope was just written optimistically; the resolution
-     * effect keeps these instead of overwriting them through read-after-write lag.
-     */
-    optimisticScopeRef: MutableRefObject<Set<string>>;
     /**
      * The single per-label write path. Diffs `desired` vs `current` over the
      * permissionable labels and grants/revokes for one principal. Returns false
@@ -48,7 +41,12 @@ export interface ILabelScope {
  * which labels are permissionable, and exposes one reconcile primitive shared by
  * add / remove / general-access / the labels picker so their behavior can't drift.
  *
+ * The resolved scope is local-authoritative: the probe seeds a scope only for
+ * grantees it doesn't already know, so an optimistic scope written for a freshly
+ * added grantee is never overwritten by the backend's lagging read. Local scopes
+ * are dropped on a target switch so the next object re-resolves from scratch.
+ *
  * @internal
  */
-export declare function useLabelScope(target: IObjectPermissionsObject | undefined, targetKey: string | undefined, labels: IObjectShareLabel[], currentAccessList: IObjectAccessList | undefined, granteeIdsKey: string, labelsError: boolean, labelsLoading: boolean): ILabelScope;
+export declare function useLabelScope(target: IObjectPermissionsObject | undefined, targetKey: string | undefined, labels: IObjectShareLabel[], hasList: boolean, committedGranteeIds: string[], labelsError: boolean, labelsLoading: boolean): ILabelScope;
 //# sourceMappingURL=useLabelScope.d.ts.map

package/esm/share/useLabelScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLabelScope.d.ts","sourceRoot":"","sources":["../../src/share/useLabelScope.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAqD,MAAM,OAAO,CAAC;AAEjG,OAAO,EAAE,KAAK,wBAAwB,EAA6B,MAAM,2BAA2B,CAAC;AACrG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG7D,OAAO,EACH,KAAK,mBAAmB,EAI3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAWpD;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB;;;;OAIG;IACH,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC;;;;;;;;OAQG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,sFAAoF;IACpF,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,4BAA4B,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7F;;;OAGG;IACH,kBAAkB,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAClD;;;;OAIG;IACH,mBAAmB,EAAE,CACjB,SAAS,EAAE,mBAAmB,EAC9B,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,EACpC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,KACnC,OAAO,CAAC,OAAO,CAAC,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,iBAAiB,EAAE,EAC3B,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,EAChD,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,OAAO,GACvB,WAAW,CAoKb"}
+{"version":3,"file":"useLabelScope.d.ts","sourceRoot":"","sources":["../../src/share/useLabelScope.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,wBAAwB,EAA6B,MAAM,2BAA2B,CAAC;AAGrG,OAAO,EACH,KAAK,mBAAmB,EAG3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAWpD;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB;;;;OAIG;IACH,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC;;;;;;;;OAQG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,sFAAoF;IACpF,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,4BAA4B,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7F;;;;OAIG;IACH,mBAAmB,EAAE,CACjB,SAAS,EAAE,mBAAmB,EAC9B,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,EACpC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,KACnC,OAAO,CAAC,OAAO,CAAC,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,iBAAiB,EAAE,EAC3B,OAAO,EAAE,OAAO,EAChB,mBAAmB,EAAE,MAAM,EAAE,EAC7B,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,OAAO,GACvB,WAAW,CAsKb"}

package/esm/share/useLabelScope.js

@@ -1,8 +1,8 @@
 // (C) 2026 GoodData Corporation
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { isUnexpectedResponseError } from "@gooddata/sdk-backend-spi";
 import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
-import { buildLabelMutations, granteesFromAccessList, isGranteeGrantedIn, } from "./objectShareController.helpers.js";
+import { buildLabelMutations, isGranteeGrantedIn, } from "./objectShareController.helpers.js";
 /**
  * Whether a label's access-list error means the label is genuinely not
  * independently permissionable (a definitive 404 / 501), as opposed to a
@@ -17,13 +17,17 @@ function isNotPermissionable(error) {
  * which labels are permissionable, and exposes one reconcile primitive shared by
  * add / remove / general-access / the labels picker so their behavior can't drift.
  *
+ * The resolved scope is local-authoritative: the probe seeds a scope only for
+ * grantees it doesn't already know, so an optimistic scope written for a freshly
+ * added grantee is never overwritten by the backend's lagging read. Local scopes
+ * are dropped on a target switch so the next object re-resolves from scratch.
+ *
  * @internal
  */
-export function useLabelScope(target, targetKey, labels, currentAccessList, granteeIdsKey, labelsError, labelsLoading) {
+export function useLabelScope(target, targetKey, labels, hasList, committedGranteeIds, labelsError, labelsLoading) {
     const backend = useBackendStrict();
     const workspace = useWorkspaceStrict();
     const [selectedLabelIdsByGrantee, setSelectedLabelIdsByGrantee] = useState({});
-    const optimisticScopeRef = useRef(new Set());
     // Label ids whose permissions endpoint responded — not every display form is
     // independently permissionable (some 404). `undefined` means "not resolved
     // yet" (assume all).
@@ -39,19 +43,30 @@ export function useLabelScope(target, targetKey, labels, currentAccessList, gran
     useEffect(() => {
         setPermissionableLabelIds(undefined);
     }, [targetKey, labelsKey]);
+    // A target switch — or a label-set change under the same target (labels finish
+    // loading, a label added/removed) — drops every resolved scope so the seeding
+    // effect below re-resolves from the current label set's per-label lists rather
+    // than preserving scopes computed against the old labels. Without the labelsKey
+    // reset, an existing grantee would keep a scope missing a newly-added label even
+    // when the backend grants them access to it. (An add under the SAME labels only
+    // changes granteeIdsKey, not labelsKey, so an optimistic scope still survives.)
+    useEffect(() => {
+        setSelectedLabelIdsByGrantee({});
+    }, [targetKey, labelsKey]);
+    // Stable string key of the committed grantee ids — the array is rebuilt each
+    // render, so the effect keys on this instead to re-resolve only on a real change.
+    const granteeIdsKey = committedGranteeIds.slice().sort().join(",");
     // Resolve each grantee's label scope: fetch every label's access list once and
     // record, per grantee, which labels they appear in (primary label always counts).
     // Keyed on the committed grantee ids + labels so it re-resolves after add/remove.
-    // `hasAccessList` is a dep too: a list that loads with no named grantees keeps
+    // `hasList` is a dep too: a list that loads with no named grantees keeps
     // `granteeIdsKey` empty, so without it the effect would never run and the
     // permissionable set (404 filtering) would never resolve.
-    const hasAccessList = currentAccessList !== undefined;
     useEffect(() => {
-        if (!target || labels.length === 0 || !currentAccessList) {
+        if (!target || labels.length === 0 || !hasList) {
             return;
         }
         let cancelled = false;
-        const committedGranteeIds = granteesFromAccessList(currentAccessList).map((g) => g.id);
         Promise.all(labels.map((label) => backend
             .workspace(workspace)
             .objectPermissions()
@@ -89,13 +104,14 @@ export function useLabelScope(target, targetKey, labels, currentAccessList, gran
                 }
             }
             setSelectedLabelIdsByGrantee((prev) => {
-                // Keep a just-written optimistic scope through read-after-write lag;
-                // take the freshly-resolved scope for everyone else.
-                const next = { ...resolved };
-                for (const id of optimisticScopeRef.current) {
-                    if (prev[id]) {
-                        next[id] = prev[id];
-                    }
+                // Seed a scope only for grantees we don't already have one for. A
+                // scope written optimistically (a fresh add, a labels edit) is
+                // local-authoritative and must survive the re-resolution that the
+                // grantee-set change triggers — the backend's lagging read would
+                // otherwise reset it. Grantees gone from the list are dropped.
+                const next = {};
+                for (const id of committedGranteeIds) {
+                    next[id] = prev[id] ?? resolved[id];
                 }
                 return next;
             });
@@ -105,23 +121,14 @@ export function useLabelScope(target, targetKey, labels, currentAccessList, gran
             cancelled = true;
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [backend, workspace, targetKey, labelsKey, granteeIdsKey, hasAccessList]);
-    // A label-set change OR a target switch re-resolves scopes; drop the optimistic-
-    // scope guard so the freshly-resolved scopes aren't held stale. Keying on
-    // labelsKey alone leaked across objects that happen to share a labelsKey (e.g.
-    // during navigation, before the new object's labels load): the prior object's
-    // optimistic entries would then merge over the new object's resolved scopes and
-    // show/save the wrong label grants. targetKey makes the guard per-object.
-    useEffect(() => {
-        optimisticScopeRef.current = new Set();
-    }, [labelsKey, targetKey]);
+    }, [backend, workspace, targetKey, labelsKey, granteeIdsKey, hasList]);
     // Only labels whose permissions endpoint responded are scope-controllable; until
     // resolution completes (permissionableLabelIds undefined) assume all are usable.
     // While the current target's list isn't loaded yet, ignore a permissionable set
     // left over from a previous object so we never mis-filter the new labels.
-    const effectiveLabels = useMemo(() => currentAccessList && permissionableLabelIds
+    const effectiveLabels = useMemo(() => hasList && permissionableLabelIds
         ? labels.filter((l) => permissionableLabelIds.has(l.id))
-        : labels, [labels, permissionableLabelIds, currentAccessList]);
+        : labels, [labels, permissionableLabelIds, hasList]);
     // Resolution is done when the probe has produced a permissionable set, or when
     // there are genuinely no labels to probe (a label-free object). Until then
     // callers must treat the scope as unknown (not "all selected").
@@ -154,7 +161,6 @@ export function useLabelScope(target, targetKey, labels, currentAccessList, gran
         labelsResolved,
         selectedLabelIdsByGrantee,
         setSelectedLabelIdsByGrantee,
-        optimisticScopeRef,
         reconcileLabelScope,
     };
 }

package/esm/share/useObjectShareController.d.ts

@@ -1,24 +1,27 @@
 import type { IObjectPermissionsObject } from "@gooddata/sdk-backend-spi";
-import { type IObjectShareController } from "./objectShareController.types.js";
-import type { IObjectShareLabel } from "./types.js";
+import { type IObjectShareController, type IUseObjectShareOptions } from "./objectShareController.types.js";
 /**
- * Manages the share dialog state and backend I/O for a single shareable
- * object.
+ * Manages the share dialog state and backend I/O for a single shareable object.
  *
- * The access list is fetched (and re-fetched after every save) via
- * `useCancelablePromise`; everything that reflects the backend — the grantee
- * rows, general-access value, summary — is derived from it on render, never
- * copied into local state. Local state is only the dialog's own transient UI:
- * the active subview, the add-grantee buffer, the pending general-access
- * confirm, and an in-flight save flag. Top-level open/close is the consumer's
- * concern (see {@link ObjectShareDialog}).
+ * The access list is fetched once and seeded into local state, which is the
+ * source of truth while the dialog/summary is mounted. Each access change is
+ * written through to local state immediately and sent to the backend; on failure
+ * the one changed entry is rolled back. There is no post-write refetch, so the
+ * grantee list never blanks and never fights the backend's read-after-write lag.
+ * Top-level open/close is the consumer's concern (see {@link ObjectShareDialog}).
  *
- * Mutations follow a **commit-on-interaction** model: each access change is
- * sent immediately; the general-access toggle goes through a confirm step
- * because it is high-impact. There is no batched Save. The list is fetched
- * eagerly so `state.summary` also drives an inline access row while closed.
+ * Mutations follow a **commit-on-interaction** model: each access change is sent
+ * immediately; the general-access toggle goes through a confirm step because it
+ * is high-impact. There is no batched Save. The list is fetched eagerly so
+ * `state.summary` also drives an inline access row while closed.
+ *
+ * Most consumers do not call this directly — render {@link ObjectShareDialog} with
+ * plain props and it owns its controller. Call this (exported as `useObjectShare`)
+ * only to share a single access-list fetch between the dialog and an inline summary
+ * row: call it once, read `state.summary` for the row, and pass the controller into
+ * the dialog.
  *
  * @internal
  */
-export declare function useObjectShareController(target: IObjectPermissionsObject | undefined, onSaved?: () => void, labels?: IObjectShareLabel[], labelsError?: boolean, labelsLoading?: boolean): IObjectShareController;
+export declare function useObjectShareController(target: IObjectPermissionsObject | undefined, options?: IUseObjectShareOptions): IObjectShareController;
 //# sourceMappingURL=useObjectShareController.d.ts.map

package/esm/share/useObjectShareController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useObjectShareController.d.ts","sourceRoot":"","sources":["../../src/share/useObjectShareController.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAW1E,OAAO,EACH,KAAK,sBAAsB,EAK9B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAIpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,CAAC,EAAE,MAAM,IAAI,EACpB,MAAM,GAAE,iBAAiB,EAAc,EACvC,WAAW,UAAQ,EACnB,aAAa,UAAQ,GACtB,sBAAsB,CAyZxB"}
+{"version":3,"file":"useObjectShareController.d.ts","sourceRoot":"","sources":["../../src/share/useObjectShareController.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAa1E,OAAO,EACH,KAAK,sBAAsB,EAI3B,KAAK,sBAAsB,EAE9B,MAAM,kCAAkC,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,CAAC,EAAE,sBAAsB,GACjC,sBAAsB,CAggBxB"}