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

package/esm/share/objectShareController.helpers.js

@@ -12,9 +12,11 @@ export function assigneeMatchesQuery(assignee, query) {
     const email = assignee.type === "user" ? (assignee.email ?? "") : "";
     return `${assignee.name} ${email}`.toLowerCase().includes(query);
 }
-/** The row's directly-granted level. SHARE outranks VIEW. */
+/** Permission levels from strongest to weakest; the row shows the strongest it holds. */
+const LEVELS_STRONGEST_FIRST = ["EDIT", "SHARE", "VIEW"];
+/** The row's directly-granted level — the strongest permission present, defaulting to VIEW. */
 export function directLevel(permissions) {
-    return permissions.includes("SHARE") ? "SHARE" : "VIEW";
+    return LEVELS_STRONGEST_FIRST.find((level) => permissions.includes(level)) ?? "VIEW";
 }
 /**
  * The effective permission to surface as a warning, or undefined when the direct
@@ -23,7 +25,17 @@ export function directLevel(permissions) {
  * than what the row's permission control shows.
  */
 export function effectivePermissionAbove(direct, inheritedPermissions) {
-    return direct !== "SHARE" && inheritedPermissions.includes("SHARE") ? "SHARE" : undefined;
+    // A direct EDIT already outranks any inherited SHARE — never warn in that case.
+    return direct === "VIEW" && inheritedPermissions.includes("SHARE") ? "SHARE" : undefined;
+}
+/** The permission-derived fields shared by every grantee row, regardless of kind. */
+function granteeAccess(permissions, inheritedPermissions) {
+    const level = directLevel(permissions);
+    return {
+        level,
+        effectivePermission: effectivePermissionAbove(level, inheritedPermissions),
+        inheritsShare: inheritedPermissions.includes("SHARE"),
+    };
 }
 export function granteesFromAccessList(list) {
     if (!list) {
@@ -32,71 +44,36 @@ export function granteesFromAccessList(list) {
     const out = [];
     for (const g of list.grants) {
         if (isGranularUserAccess(g)) {
-            const level = directLevel(g.permissions);
             out.push({
                 id: granteeId("user", g.user.ref),
                 kind: "user",
                 granteeRef: g.user.ref,
                 name: g.user.fullName ?? g.user.email ?? g.user.login,
                 email: g.user.email,
-                level,
-                effectivePermission: effectivePermissionAbove(level, g.inheritedPermissions),
+                ...granteeAccess(g.permissions, g.inheritedPermissions),
             });
         }
         else if (isGranularUserGroupAccess(g)) {
-            const level = directLevel(g.permissions);
             out.push({
                 id: granteeId("group", g.userGroup.ref),
                 kind: "group",
                 granteeRef: g.userGroup.ref,
                 name: g.userGroup.name ?? objRefToString(g.userGroup.ref),
-                level,
-                effectivePermission: effectivePermissionAbove(level, g.inheritedPermissions),
+                ...granteeAccess(g.permissions, g.inheritedPermissions),
             });
         }
     }
     return out;
 }
-/**
- * Merge the committed rows with the optimistic overlay: `set` replaces/inserts a
- * row (annotated pending), `remove` drops it. Entries with no committed effect
- * still apply so the UI reflects the user's intent during read-after-write lag.
- */
-export function mergeOverlay(committed, overlay) {
-    const byId = new Map(committed.map((g) => [g.id, g]));
-    for (const [id, entry] of Object.entries(overlay)) {
-        if (entry.op === "remove") {
-            byId.delete(id);
-        }
-        else {
-            byId.set(id, { ...entry.grantee, pending: entry.pending ? "saving" : undefined });
-        }
-    }
-    return [...byId.values()];
-}
-/**
- * Drop overlay entries the freshly-fetched list now confirms: a `set` whose
- * committed level matches the intended level, or a `remove` whose grantee is
- * gone. Unconfirmed entries are kept (server still lagging) but lose `pending`
- * so the row shows the intended value without a spinner.
- */
-export function reconcileOverlay(committed, overlay) {
-    const byId = new Map(committed.map((g) => [g.id, g]));
-    const next = {};
-    for (const [id, entry] of Object.entries(overlay)) {
-        if (entry.op === "remove") {
-            if (byId.has(id)) {
-                next[id] = { op: "remove", pending: false };
-            }
-        }
-        else if (byId.get(id)?.level !== entry.grantee.level) {
-            next[id] = { op: "set", grantee: entry.grantee, pending: false };
-        }
-    }
-    return next;
-}
+/** The permission set a grant carries at each level; a higher level always implies VIEW. */
+const PERMISSIONS_BY_LEVEL = {
+    none: [],
+    VIEW: ["VIEW"],
+    SHARE: ["SHARE", "VIEW"],
+    EDIT: ["EDIT", "VIEW"],
+};
 export function toGranularGrantee(kind, granteeRef, level) {
-    const permissions = level === "none" ? [] : level === "SHARE" ? ["SHARE", "VIEW"] : ["VIEW"];
+    const permissions = PERMISSIONS_BY_LEVEL[level];
     return kind === "user"
         ? { type: "granularUser", granteeRef, permissions, inheritedPermissions: [] }
         : { type: "granularGroup", granteeRef, permissions, inheritedPermissions: [] };

package/esm/share/objectShareController.types.d.ts

@@ -1,13 +1,16 @@
-import type { ObjRef } from "@gooddata/sdk-model";
+import type { AccessGranularPermission, ObjRef } from "@gooddata/sdk-model";
 import type { GeneralAccessValue, IUiGranteeAsyncOptions, IUiPickedGrantee } from "@gooddata/sdk-ui-kit";
 import type { IObjectAccessSummary, IObjectShareLabel } from "./types.js";
 /**
- * Permission level surfaced in the share dialog. `EDIT` is intentionally
- * not represented — the underlying permission menu caps at VIEW/SHARE.
+ * Permission level surfaced in the share dialog — the model's granular access
+ * permission (VIEW / EDIT / SHARE). `EDIT` is display-only: the dialog reflects
+ * an EDIT grant as a read-only "Can edit" row but cannot assign or change it
+ * (granting EDIT is not part of the share UI), so only VIEW and SHARE are
+ * selectable in the permission menu.
  *
  * @internal
  */
-export type ObjectSharePermissionLevel = "VIEW" | "SHARE";
+export type ObjectSharePermissionLevel = AccessGranularPermission;
 /**
  * Dialog row derived from a backend grant.
  *
@@ -28,6 +31,12 @@ export interface IObjectShareGrantee {
      * the row's "effective permission" warning badge.
      */
     effectivePermission?: ObjectSharePermissionLevel;
+    /**
+     * Whether the grantee inherits SHARE (e.g. via a group), regardless of the
+     * current direct `level`. Retained from the fetch so `effectivePermission` can
+     * be recomputed locally when the direct level changes (no refetch).
+     */
+    inheritsShare?: boolean;
     /**
      * Row-level in-flight state for optimistic updates: `"saving"` while a level
      * change or freshly-added grant is being committed, `"removing"` while a
@@ -107,4 +116,37 @@ export interface IObjectShareController {
     state: IObjectShareControllerState;
     actions: IObjectShareControllerActions;
 }
+/**
+ * Options for {@link useObjectShare}.
+ *
+ * @internal
+ */
+export interface IUseObjectShareOptions {
+    /**
+     * Fires after each successful access mutation (add grantee, change level,
+     * remove, general access toggle). Use it to keep UI outside the dialog in
+     * sync with edits made inside it (e.g. refresh an inline access row).
+     */
+    onSaved?: () => void;
+    /**
+     * Labels (display forms) of the shared attribute, enabling the per-grantee
+     * label-scope picker. Omit for objects without labels (e.g. facts).
+     */
+    labels?: IObjectShareLabel[];
+    /**
+     * Whether loading the object's labels failed. While true the controller stays
+     * label-unresolved so every access-changing control is disabled: with the
+     * label set unknown, reconciling access would diff against an empty set and
+     * silently orphan any real per-label grants. Distinct from an object that
+     * genuinely has no labels (omit `labels`), where editing is safe.
+     */
+    labelsError?: boolean;
+    /**
+     * Whether the object's labels are still loading. While true the controller stays
+     * label-unresolved (same gating as `labelsError`): the labels aren't passed yet,
+     * so an empty list must not be mistaken for a label-free object — otherwise row
+     * controls would reconcile against an empty set and orphan real per-label grants.
+     */
+    labelsLoading?: boolean;
+}
 //# sourceMappingURL=objectShareController.types.d.ts.map

package/esm/share/objectShareController.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectShareController.types.d.ts","sourceRoot":"","sources":["../../src/share/objectShareController.types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEzG,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAAG,MAAM,GAAG,OAAO,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAChC,kFAAkF;IAClF,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,0BAA0B,CAAC;IAClC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,0BAA0B,CAAC;IACjD;;;;OAIG;IACH,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IACxC,OAAO,EAAE,MAAM,GAAG,YAAY,CAAC;IAC/B,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC5D,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAE1C,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,aAAa,EAAE,kBAAkB,CAAC;IAElC;;;OAGG;IACH,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAEpD,mEAAiE;IACjE,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;IAC1C,qEAAqE;IACrE,eAAe,EAAE,gBAAgB,EAAE,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC1C,sFAAsF;IACtF,KAAK,EAAE,MAAM,IAAI,CAAC;IAElB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,kBAAkB,EAAE,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,IAAI,CAAC;IACvD;;;;OAIG;IACH,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACjE,kDAAkD;IAClD,kBAAkB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAExC,oEAAoE;IACpE,qBAAqB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,0BAA0B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/F,oCAAoC;IACpC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD;;;OAGG;IACH,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtF,+DAA+D;IAC/D,0BAA0B,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAC/D,yBAAyB,EAAE,MAAM,IAAI,CAAC;IACtC,4DAA4D;IAC5D,0BAA0B,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,KAAK,EAAE,2BAA2B,CAAC;IACnC,OAAO,EAAE,6BAA6B,CAAC;CAC1C"}
+{"version":3,"file":"objectShareController.types.d.ts","sourceRoot":"","sources":["../../src/share/objectShareController.types.ts"],"names":[],"mappings":"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"}

package/esm/share/useAccessList.d.ts

@@ -1,32 +1,31 @@
 import type { IObjectPermissionsObject } from "@gooddata/sdk-backend-spi";
-import { type IGranularAccessGrantee, type IObjectAccessList, type ObjRef } from "@gooddata/sdk-model";
+import { type IGranularAccessGrantee, type ObjRef } from "@gooddata/sdk-model";
 import { type GeneralAccessValue, type IUiGranteeAsyncOptions } from "@gooddata/sdk-ui-kit";
-import { type IGranteeOverlayEntry } from "./objectShareController.helpers.js";
 import type { IObjectShareControllerState, IObjectShareGrantee } from "./objectShareController.types.js";
 import type { IObjectAccessSummary } from "./types.js";
 /**
- * The owned access list + optimistic overlay for {@link useObjectShareController}.
+ * The owned access list for {@link useObjectShareController}.
  *
  * @internal
  */
 export interface IAccessList {
     /** Stable serialized key of the current target's ref, or undefined when none. */
     targetKey: string | undefined;
-    /** The owned list as it applies to the *current* target (undefined while a switch is pending). */
-    currentAccessList: IObjectAccessList | undefined;
-    /** Committed grantee rows overlaid with optimistic intent (add/level/remove). */
+    /** True once the current target's list has been fetched and seeded into local state. */
+    hasList: boolean;
+    /** Local grantee rows — seeded from the fetch, then authoritative; mutations write through. */
     grantees: IObjectShareGrantee[];
-    /** Sorted, comma-joined committed grantee ids — a stable key for resolution effects. */
-    granteeIdsKey: string;
-    /** Optimistic-aware general access (workspace vs restricted). */
+    /** Workspace vs restricted general access — local state; mutations write through. */
     generalAccess: GeneralAccessValue;
-    /** Inline access summary (optimistic-aware), or undefined before the first load. */
+    /** Workspace-rule permission level (VIEW/SHARE) — local state; mutations write through. */
+    workspaceLevel: "VIEW" | "SHARE";
+    /** Inline access summary, or undefined before the first load. */
     summary: IObjectAccessSummary | undefined;
     /** Top-level load status surfaced as the controller status. */
     status: IObjectShareControllerState["status"];
     /** Error from the initial/target-change load. */
     loadError: Error | undefined;
-    /** Commit a grant change, toast on success, then background-refresh. False on failure. */
+    /** Write a grant change to the backend and toast. False on failure; no refetch. */
     commit: (mutate: IGranularAccessGrantee[], successMessage: {
         id: string;
     }) => Promise<boolean>;
@@ -34,16 +33,30 @@ export interface IAccessList {
     loadOptions: (search: string) => Promise<IUiGranteeAsyncOptions>;
     /** Resolve a grantee id back to the picker's original ObjRef (preserves Uri vs Id ref). */
     refForId: (id: string) => ObjRef;
-    setOverlay: React.Dispatch<React.SetStateAction<Record<string, IGranteeOverlayEntry>>>;
+    /** Write through a local grantee-row change (insert / level / remove); rolled back by the caller. */
+    setGrantees: React.Dispatch<React.SetStateAction<IObjectShareGrantee[]>>;
+    /** Write through a local general-access change; rolled back by the caller. */
+    setGeneralAccess: React.Dispatch<React.SetStateAction<GeneralAccessValue>>;
+    /**
+     * Write through the local workspace-rule permission level. A general-access write
+     * always grants workspace VIEW, so the caller sets this to keep the summary from
+     * showing a stale SHARE inherited from the initial fetch.
+     */
+    setWorkspaceLevel: React.Dispatch<React.SetStateAction<"VIEW" | "SHARE">>;
     setKnownNames: React.Dispatch<React.SetStateAction<Record<string, string>>>;
-    setOptimisticGeneralAccess: React.Dispatch<React.SetStateAction<GeneralAccessValue | undefined>>;
 }
 /**
- * Owns the backend access list and its optimistic overlay. The list is fetched
- * via `useCancelablePromise` then owned locally: mutations patch the overlay and
- * a background refresh reconciles it, so the grantee list never blanks between a
- * change and the server response. A target switch is handled by stamping the
- * fetched list with its target and reading through `currentAccessList`.
+ * Owns the backend access list. It is fetched once (per target) then seeded into
+ * local state, which is authoritative while the dialog/summary is mounted:
+ * mutations write through to it directly and roll back the one changed entry on
+ * failure. There is no post-write refetch, so the grantee list never blanks and
+ * never fights the backend's read-after-write lag. A target switch re-seeds from
+ * the new fetch; the seed is gated on a per-target stamp so a late fetch for a
+ * previous target can't clobber the current one.
+ *
+ * Effective (inherited) permissions and display names come from that single
+ * fetch: inherited access doesn't change as a result of editing a direct grant,
+ * so the badge stays correct for the session without re-reading.
  *
  * @internal
  */

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

@@ -1 +1 @@
-{"version":3,"file":"useAccessList.d.ts","sourceRoot":"","sources":["../../src/share/useAccessList.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EACH,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,MAAM,EAEd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAmB,MAAM,sBAAsB,CAAC;AAI7G,OAAO,EACH,KAAK,oBAAoB,EAM5B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACzG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,iFAAiF;IACjF,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,kGAAkG;IAClG,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACjD,iFAAiF;IACjF,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,0FAAwF;IACxF,aAAa,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,aAAa,EAAE,kBAAkB,CAAC;IAClC,oFAAoF;IACpF,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,+DAA+D;IAC/D,MAAM,EAAE,2BAA2B,CAAC,QAAQ,CAAC,CAAC;IAC9C,iDAAiD;IACjD,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC;IAE7B,0FAA0F;IAC1F,MAAM,EAAE,CAAC,MAAM,EAAE,sBAAsB,EAAE,EAAE,cAAc,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/F,sFAAoF;IACpF,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACjE,2FAA2F;IAC3F,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAEjC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;IACvF,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC5E,0BAA0B,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC,CAAC;CACpG;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAClC,WAAW,CAsRb"}
+{"version":3,"file":"useAccessList.d.ts","sourceRoot":"","sources":["../../src/share/useAccessList.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,MAAM,EAAkB,MAAM,qBAAqB,CAAC;AAE/F,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAmB,MAAM,sBAAsB,CAAC;AAK7G,OAAO,KAAK,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACzG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,iFAAiF;IACjF,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,wFAAwF;IACxF,OAAO,EAAE,OAAO,CAAC;IACjB,iGAA+F;IAC/F,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,uFAAqF;IACrF,aAAa,EAAE,kBAAkB,CAAC;IAClC,6FAA2F;IAC3F,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,iEAAiE;IACjE,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,+DAA+D;IAC/D,MAAM,EAAE,2BAA2B,CAAC,QAAQ,CAAC,CAAC;IAC9C,iDAAiD;IACjD,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC;IAE7B,mFAAmF;IACnF,MAAM,EAAE,CAAC,MAAM,EAAE,sBAAsB,EAAE,EAAE,cAAc,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/F,sFAAoF;IACpF,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACjE,2FAA2F;IAC3F,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAEjC,qGAAqG;IACrG,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;IACzE,8EAA8E;IAC9E,gBAAgB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC;IAC3E;;;;OAIG;IACH,iBAAiB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAC1E,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;CAC/E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAClC,WAAW,CAiOb"}

package/esm/share/useAccessList.js

@@ -1,17 +1,23 @@
 // (C) 2026 GoodData Corporation
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { objRefToString, } from "@gooddata/sdk-model";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { objRefToString } from "@gooddata/sdk-model";
 import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
 import { useToastMessage } from "@gooddata/sdk-ui-kit";
 import { deriveGeneralAccess, deriveWorkspacePermissionLevel } from "./accessSummary.js";
 import { objectShareMessages } from "./messages.js";
-import { assigneeMatchesQuery, granteeId, granteesFromAccessList, mergeOverlay, reconcileOverlay, } from "./objectShareController.helpers.js";
+import { assigneeMatchesQuery, granteeId, granteesFromAccessList } from "./objectShareController.helpers.js";
 /**
- * Owns the backend access list and its optimistic overlay. The list is fetched
- * via `useCancelablePromise` then owned locally: mutations patch the overlay and
- * a background refresh reconciles it, so the grantee list never blanks between a
- * change and the server response. A target switch is handled by stamping the
- * fetched list with its target and reading through `currentAccessList`.
+ * Owns the backend access list. It is fetched once (per target) then seeded into
+ * local state, which is authoritative while the dialog/summary is mounted:
+ * mutations write through to it directly and roll back the one changed entry on
+ * failure. There is no post-write refetch, so the grantee list never blanks and
+ * never fights the backend's read-after-write lag. A target switch re-seeds from
+ * the new fetch; the seed is gated on a per-target stamp so a late fetch for a
+ * previous target can't clobber the current one.
+ *
+ * Effective (inherited) permissions and display names come from that single
+ * fetch: inherited access doesn't change as a result of editing a direct grant,
+ * so the badge stays correct for the session without re-reading.
  *
  * @internal
  */
@@ -19,37 +25,24 @@ export function useAccessList(target, onSaved) {
     const backend = useBackendStrict();
     const workspace = useWorkspaceStrict();
     const toast = useToastMessage();
-    const [accessList, setAccessList] = useState(undefined);
-    const [accessListTarget, setAccessListTarget] = useState(undefined);
-    const [loadStatus, setLoadStatus] = useState(target ? "loading" : "idle");
+    // Authoritative local state, seeded from the fetch below.
+    const [grantees, setGrantees] = useState([]);
+    const [generalAccess, setGeneralAccess] = useState("RESTRICTED");
+    const [workspaceLevel, setWorkspaceLevel] = useState("VIEW");
+    // The target the local state was seeded for; undefined until the first seed.
+    // Reading state as belonging to the current target hinges on this matching
+    // `targetKey` — a target switch makes the old state stale until the re-seed.
+    const [seededTarget, setSeededTarget] = useState(undefined);
     const [loadError, setLoadError] = useState(undefined);
-    // Optimistic overlay keyed by grantee id. Each entry holds the *intended* row
-    // (add/level-change) or a removal, plus a pending flag while the write is in
-    // flight. The backend has read-after-write lag, so we show the intended state
-    // and clear an entry only once a refresh confirms it (or the write fails).
-    const [overlay, setOverlay] = useState({});
-    // Display names learned from the picker; keep a human name on a row after the
-    // optimistic overlay reconciles away (the grant often returns only a raw id).
+    // Display names learned from the picker; used to give a fetched row a human
+    // name when its grant carried only a raw id.
     const [knownNames, setKnownNames] = useState({});
     // Original ObjRef per grantee id, learned from the picker (the access-list id
     // is a serialized `kind:identifier`, which loses Uri-vs-Id). Reused for writes.
     const [knownRefs, setKnownRefs] = useState({});
-    // Optimistic general-access override — held from confirm until the fetched list
-    // reflects it, so the radio + summary update instantly.
-    const [optimisticGeneralAccess, setOptimisticGeneralAccess] = useState(undefined);
     const targetKey = target ? objRefToString(target.ref) : undefined;
-    // The owned list as it applies to the *current* target. A target switch makes
-    // the previous fetch's list stale until the new one lands; gating on the stamp
-    // means everything derived ignores it immediately — no reset effect.
-    const currentAccessList = accessListTarget === targetKey ? accessList : undefined;
-    // Always-current target key, read inside async callbacks that captured an older
-    // one. A background refresh started for the previous target can resolve after a
-    // switch; without this it would stamp the list back to the stale target, leaving
-    // the new target's `currentAccessList` undefined (and, with the load-gated
-    // status, stuck "loading" since its own fetch already settled).
-    const targetKeyRef = useRef(targetKey);
-    targetKeyRef.current = targetKey;
-    // Initial (and target-change) load. Feeds setAccessList once; thereafter we own it.
+    // Initial (and target-change) load. Seeds local state once per target; thereafter
+    // local state is authoritative and mutations write through it.
     const { result: fetchedList, status: fetchStatus, error: fetchError, } = useCancelablePromise({
         promise: target
             ? () => backend.workspace(workspace).objectPermissions().getAccessList(target)
@@ -58,118 +51,77 @@ export function useAccessList(target, onSaved) {
     // Key on the serialized ref, not the ObjRef object — an inline idRef(...) is a
     // new instance each render and would otherwise refetch forever.
     [backend, workspace, target?.kind, targetKey]);
+    // Local state belongs to the current target only once its list has been seeded
+    // AND no fetch is in flight for it. Requiring `fetchStatus === "success"` (not
+    // just a matching `seededTarget`) matters when the same object is reopened after
+    // navigating away: the deps change re-runs `useCancelablePromise`, which resets to
+    // `loading` while it refetches. Without this, the still-matching previous
+    // `seededTarget` would keep `hasList` true and surface the prior session's
+    // grantees as `success` (mutations enabled) until the new list lands.
+    const hasList = seededTarget === targetKey && targetKey !== undefined && fetchStatus === "success";
     useEffect(() => {
         if (fetchStatus === "success" && fetchedList) {
             // The cancelable promise is keyed on targetKey, so this list is for it.
-            setAccessList(fetchedList);
-            setAccessListTarget(targetKey);
-            setLoadStatus("idle");
+            setGrantees(granteesFromAccessList(fetchedList));
+            setGeneralAccess(deriveGeneralAccess(fetchedList.grants));
+            setWorkspaceLevel(deriveWorkspacePermissionLevel(fetchedList.grants));
+            setSeededTarget(targetKey);
             setLoadError(undefined);
-            setOverlay({}); // a target-change load is authoritative; drop stale overlay
-            setOptimisticGeneralAccess(undefined);
         }
         else if (fetchStatus === "error") {
-            setLoadStatus("error");
             setLoadError(fetchError instanceof Error ? fetchError : new Error(String(fetchError)));
         }
         else if (fetchStatus === "loading") {
-            setLoadStatus("loading");
+            // A (re)fetch is in flight — including when the same object is reopened
+            // after navigating away. Drop the seed stamp so the previous session's
+            // list isn't surfaced as the current one until the fresh fetch is seeded.
+            setSeededTarget(undefined);
         }
     }, [fetchStatus, fetchedList, fetchError, targetKey]);
-    // Background refresh — pulls server truth without nulling the current list,
-    // then reconciles the overlay (clears entries the server now confirms).
-    const refresh = useCallback(async () => {
-        if (!target) {
-            return;
-        }
-        try {
-            const fresh = await backend.workspace(workspace).objectPermissions().getAccessList(target);
-            // The target may have changed while this refresh was in flight. Stamping
-            // a stale target's list now would clobber the new target's stamp and
-            // strand it loading, so drop the result if we've since switched away.
-            if (targetKeyRef.current !== targetKey) {
-                return;
-            }
-            setAccessList(fresh);
-            setAccessListTarget(targetKey);
-            setOverlay((prev) => reconcileOverlay(granteesFromAccessList(fresh), prev));
-            // Drop the optimistic general-access override once the server confirms it.
-            const freshGeneralAccess = deriveGeneralAccess(fresh.grants);
-            setOptimisticGeneralAccess((prev) => (prev === freshGeneralAccess ? undefined : prev));
-        }
-        catch {
-            // The refresh failed, but the mutation that triggered it already
-            // succeeded. The overlay can't be reconciled against fresh data now, so
-            // settle it optimistically: keep each entry's intended state (a `set`
-            // value stays, a `remove` keeps hiding the row) but clear its `pending`
-            // flag. Otherwise rows would spin on "saving"/"removing" forever even
-            // though the change persisted and a success toast was shown.
-            setOverlay((prev) => {
-                let changed = false;
-                const next = {};
-                for (const [id, entry] of Object.entries(prev)) {
-                    if (entry.pending) {
-                        changed = true;
-                        next[id] = { ...entry, pending: false };
-                    }
-                    else {
-                        next[id] = entry;
-                    }
-                }
-                return changed ? next : prev;
-            });
-        }
-    }, [backend, workspace, target, targetKey]);
-    // Committed rows overlaid with optimistic intent; backfill a human name from
-    // the picker cache where the grant only carried a raw id.
-    const grantees = useMemo(() => {
-        if (!currentAccessList) {
-            return [];
-        }
-        const committed = granteesFromAccessList(currentAccessList).map((g) => {
+    // The current target's rows, with a human name backfilled from the picker
+    // cache where the grant returned only a raw id. Empty until the current
+    // target's list is seeded, so a stale previous target's rows never show
+    // through the switch window. Derivation, not state — re-applies as the cache grows.
+    const namedGrantees = useMemo(() => hasList
+        ? grantees.map((g) => {
             const known = knownNames[g.id];
             return known && g.name === objRefToString(g.granteeRef) ? { ...g, name: known } : g;
-        });
-        return mergeOverlay(committed, overlay);
-    }, [currentAccessList, overlay, knownNames]);
-    const granteeIdsKey = granteesFromAccessList(currentAccessList)
+        })
+        : [], [hasList, grantees, knownNames]);
+    // Stable sorted key of the currently-granted ids — drives the picker's
+    // "exclude already-granted" filter. Keyed on ids only (not names), so the
+    // picker's own name-cache writes can't change loadOptions' identity and
+    // re-trigger its fetch.
+    const excludedIdsKey = useMemo(() => grantees
+        .filter((g) => g.pending !== "removing")
         .map((g) => g.id)
         .sort()
-        .join(",");
-    const committedGeneralAccess = useMemo(() => (currentAccessList ? deriveGeneralAccess(currentAccessList.grants) : "RESTRICTED"), [currentAccessList]);
-    const generalAccess = optimisticGeneralAccess ?? committedGeneralAccess;
+        .join(","), [grantees]);
     const summary = useMemo(() => {
-        if (!currentAccessList) {
+        if (!hasList) {
             return undefined;
         }
         return {
             generalAccess,
-            // While the optimistic override is active we just wrote the workspace
-            // rule as VIEW, so report VIEW rather than the stale fetched grant
-            // (which can still read SHARE through read-after-write lag).
-            workspaceLevel: optimisticGeneralAccess
-                ? "VIEW"
-                : deriveWorkspacePermissionLevel(currentAccessList.grants),
-            granteeCount: grantees.length,
+            workspaceLevel: generalAccess === "WORKSPACE" ? workspaceLevel : "VIEW",
+            granteeCount: namedGrantees.filter((g) => g.pending !== "removing").length,
         };
-    }, [currentAccessList, generalAccess, optimisticGeneralAccess, grantees]);
-    // "success" only once the *current* target's list has actually landed. After a
-    // target switch the stamp clears `currentAccessList` immediately, but
-    // `loadStatus` still reads "idle" from the previous target's completed load
-    // until the effect re-runs — so gating on loadStatus alone would briefly report
-    // "success" with no list, letting the dialog enable mutations and the catalog
-    // row hide both summary and skeleton. Treat "no list for this target yet" as
-    // loading.
+    }, [hasList, generalAccess, workspaceLevel, namedGrantees]);
+    // "success" only once the *current* target's list has been seeded. After a
+    // target switch the previous seed is stale (seededTarget !== targetKey), so
+    // gating on hasList keeps the status at "loading" until the new list lands —
+    // never "success" with no list, which would let the dialog enable mutations
+    // and the catalog row hide both summary and skeleton.
     const status = target
-        ? loadStatus === "error"
+        ? fetchStatus === "error"
             ? "error"
-            : loadStatus === "loading" || !currentAccessList
-                ? "loading"
-                : "success"
+            : hasList
+                ? "success"
+                : "loading"
         : "idle";
-    // Commit a single grant change against the backend, then reconcile via refresh.
-    // Optimistic state is applied by the caller; on failure the caller's rollback
-    // runs and a toast is shown.
+    // Write a single grant change to the backend, then toast. The caller applies
+    // the optimistic local write-through and rolls it back on failure; there is no
+    // refetch — local state stays authoritative.
     const commit = useCallback(async (mutate, successMessage) => {
         if (!target) {
             return false;
@@ -181,18 +133,17 @@ export function useAccessList(target, onSaved) {
                 .manageObjectPermissions(target, mutate);
             toast.addSuccess(successMessage);
             onSaved?.();
-            await refresh();
             return true;
         }
         catch {
             toast.addError(objectShareMessages.toastError);
             return false;
         }
-    }, [backend, workspace, target, toast, onSaved, refresh]);
+    }, [backend, workspace, target, toast, onSaved]);
     // Picker loader — fetches available assignees on demand, filters by the typed
-    // query, excludes anything already granted. Depends only on the grant sources
-    // (accessList, overlay), so its identity changes only when the granted set
-    // actually changes. It must NOT write state that feeds its own deps.
+    // query, excludes anything already granted. Depends only on the granted set
+    // (grantees), so its identity changes only when that set actually changes. It
+    // must NOT write state that feeds its own deps.
     const loadOptions = useCallback(async (search) => {
         if (!target) {
             return { groups: [], users: [] };
@@ -223,7 +174,7 @@ export function useAccessList(target, onSaved) {
             }
             return next;
         });
-        const excluded = new Set(mergeOverlay(granteesFromAccessList(currentAccessList), overlay).map((g) => g.id));
+        const excluded = new Set(excludedIdsKey ? excludedIdsKey.split(",") : []);
         const selectable = withIds
             .filter(({ id }) => !excluded.has(id)) // hide anyone already granted
             .filter(({ assignee }) => assigneeMatchesQuery(assignee, query));
@@ -240,24 +191,25 @@ export function useAccessList(target, onSaved) {
                 .filter(({ assignee }) => assignee.type !== "user")
                 .map(({ assignee, id }) => ({ id, kind: "group", name: assignee.name })),
         };
-    }, [backend, workspace, target, currentAccessList, overlay]);
+    }, [backend, workspace, target, excludedIdsKey]);
     // Reuse the picker's original ref (preserves UriRef vs IdentifierRef);
     // fall back to the serialized id only if it wasn't cached.
     const refForId = useCallback((id) => knownRefs[id] ?? { identifier: id.split(":", 2)[1] }, [knownRefs]);
     return {
         targetKey,
-        currentAccessList,
-        grantees,
-        granteeIdsKey,
+        hasList,
+        grantees: namedGrantees,
         generalAccess,
+        workspaceLevel,
         summary,
         status,
         loadError,
         commit,
         loadOptions,
         refForId,
-        setOverlay,
+        setGrantees,
+        setGeneralAccess,
+        setWorkspaceLevel,
         setKnownNames,
-        setOptimisticGeneralAccess,
     };
 }