@reekon-tools/boldr-utils 1.20.2 → 1.21.0

package/dist/annotation/canvas/AnnotationCanvasInner.d.ts

@@ -41,6 +41,7 @@ export interface AnnotationCanvasInnerProps {
     initialViewport?: ViewportState;
     style?: CSSProperties;
     magnifierTopOffset?: number;
+    onInteractingChange?: (interacting: boolean) => void;
     imperativeRef?: MutableRefObject<AnnotationCanvasHandle | null>;
     snapshotRef?: MutableRefObject<(() => Uint8Array | null) | null>;
 }

package/dist/annotation/canvas/AnnotationCanvasInner.native.d.ts

@@ -42,6 +42,7 @@ export interface AnnotationCanvasInnerProps {
     initialViewport?: ViewportState;
     style?: ViewStyle;
     magnifierTopOffset?: number;
+    onInteractingChange?: (interacting: boolean) => void;
     imperativeRef?: MutableRefObject<AnnotationCanvasHandle | null>;
     snapshotRef?: MutableRefObject<(() => Uint8Array | null) | null>;
 }

package/dist/annotation/canvas/AnnotationCanvasInner.native.js

@@ -65,7 +65,7 @@ const LOUPE_CROSS_WIDTH_PX = 1.5;
 // is only re-synced once each gesture ends. The tool/tap path still hops to
 // JS (`runOnJS(true)`) since drawing/selection are React-state operations.
 export const AnnotationCanvasInner = (props) => {
-    const { resolveImageUrl, deferBackgroundToResolver, hideLinkBadges, stampFontSource, stampValueFontSize = 14, width, height, style, magnifierTopOffset = 0, snapToGeometry = false, renderBackground, } = props;
+    const { resolveImageUrl, deferBackgroundToResolver, hideLinkBadges, stampFontSource, stampValueFontSize = 14, width, height, style, magnifierTopOffset = 0, onInteractingChange, snapToGeometry = false, renderBackground, } = props;
     const valueFont = useFont(stampFontSource, stampValueFontSize);
     // The animated-viewport implementation needs the Reanimated shared values,
     // which are created below AFTER the state hook — so the hook gets a stable
@@ -159,6 +159,13 @@ export const AnnotationCanvasInner = (props) => {
     const magTouchX = useSharedValue(0);
     const magTouchY = useSharedValue(0);
     const [magnifying, setMagnifying] = useState(false);
+    // Viewport pan/zoom in motion. Set from the viewport pan/pinch onChange
+    // worklets on the first frame that actually moves the viewport (never their
+    // onBegin, which fires for plain taps too) and cleared when the LAST
+    // viewport gesture finalizes — the two run simultaneously during a
+    // two-finger gesture, hence the endViewportGesture ref-count check rather
+    // than clearing per-gesture.
+    const [viewportMoving, setViewportMoving] = useState(false);
     // Lens geometry (screen points): a fixed square in the top-left, pushed below
     // any overlaid toolbar by magnifierTopOffset. Its CENTER maps to the live
     // touch point, so the magnified slice is the canvas around the finger.
@@ -474,6 +481,22 @@ export const AnnotationCanvasInner = (props) => {
     // per-frame JS. The Skia line stays static (draggingId is NOT set), only the
     // tile moves.
     const [slidingId, setSlidingId] = useState(null);
+    // Consumer notification (onInteractingChange): `magnifying` covers every
+    // precision gesture (set on actual movement, cleared on every finalize
+    // path); whole-element moves and tile slides deliberately DON'T show the
+    // loupe, so their gating ids are OR'd in here — as is viewport motion.
+    // (The other sub-drag ids — endpoint/corner/crop — all set `magnifying`
+    // alongside their own id, so they're already covered.) Ref-guarded so a
+    // consumer that re-renders us doesn't get duplicate notifications, and so
+    // the mount render doesn't fire a spurious `false`.
+    const interacting = magnifying || viewportMoving || draggingId != null || slidingId != null;
+    const notifiedInteractingRef = useRef(false);
+    useEffect(() => {
+        if (notifiedInteractingRef.current === interacting)
+            return;
+        notifiedInteractingRef.current = interacting;
+        onInteractingChange?.(interacting);
+    }, [interacting, onInteractingChange]);
     const slideCtx = useSharedValue({ ax: 0, ay: 0, bx: 0, by: 0, t0: 0.5 });
     const slideTargetRef = useRef(null);
     // Endpoint drag (resize/rotate a measurement annotation's line). `epDragId`
@@ -1139,6 +1162,10 @@ export const AnnotationCanvasInner = (props) => {
         };
         const endViewportGesture = () => {
             activeViewportGestures.current = Math.max(0, activeViewportGestures.current - 1);
+            // Simultaneous pan+pinch: only the LAST finalize ends "viewport moving"
+            // (a no-op setState when it never started — onChange never fired).
+            if (activeViewportGestures.current === 0)
+                setViewportMoving(false);
         };
         const toolPan = Gesture.Pan()
             .minPointers(1)
@@ -1274,6 +1301,10 @@ export const AnnotationCanvasInner = (props) => {
             'worklet';
             panX.value -= e.changeX / zoom.value;
             panY.value -= e.changeY / zoom.value;
+            // First frame of actual movement flips "viewport moving" (gated on
+            // the dirty bit so it's one JS hop per gesture, not per frame).
+            if (!viewportDirty.value)
+                runOnJS(setViewportMoving)(true);
             viewportDirty.value = true;
         })
             // onFinalize, not onEnd: on Android this pan normally exits through
@@ -1344,6 +1375,10 @@ export const AnnotationCanvasInner = (props) => {
             panX.value = focalWorldX - e.focalX / next;
             panY.value = focalWorldY - e.focalY / next;
             zoom.value = next;
+            // Same first-movement flip as the pan (see there) — the early returns
+            // above keep a no-op pinch from ever firing it.
+            if (!viewportDirty.value)
+                runOnJS(setViewportMoving)(true);
             viewportDirty.value = true;
         })
             // onFinalize, not onEnd, for the same reason as the pan: an Android

package/dist/exports.d.ts

@@ -9,6 +9,7 @@ export * from './types/annotation.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
 export { GeneralColors, SecondaryColors, FormColors, TileColors, FormulaColors, YellowColors, RedColors, GreenColors, tailwindColors, } from './theme/colors.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
+export { ROLE_RANK, EMPTY_GRANTS, normalizeRole, roleAtLeast, effectiveRole, canView, canEdit, canManage, canManageOrg, isGuest, groupGrants, resolveAccess, type MaybeRole, type GroupedGrants, type ResolvedAccess, } from './utils/permissions.js';
 export { ALL_EXPORT_CATEGORIES, ALL_EXPORT_MEASUREMENT_DATA_FIELDS, ALL_EXPORT_OBJECT_TYPES, DEFAULT_EXPORT_CONFIG, EXPORT_EVERYTHING_CONFIG, normalizeExportConfig, type ExportCategory, type ExportConfig, type ExportImageFormat, type ExportMeasurementDataField, type ExportMeasurementFilter, type ExportObjectType, } from './export/config.js';
 export { classifyFileForExport } from './export/objectKinds.js';
 export { buildJobCsv, escapeCSVField, hyperlinkCell, type BuildJobCsvInput, type ExportObjectRow, type ExportScope, } from './export/buildJobCsv.js';

package/dist/exports.js

@@ -14,6 +14,9 @@ export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, gen
 // Shared color palette (canonical source for both apps' brand colors).
 export { GeneralColors, SecondaryColors, FormColors, TileColors, FormulaColors, YellowColors, RedColors, GreenColors, tailwindColors, } from './theme/colors.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
+// Three-level access (organization → project → job) role arithmetic. Keep in
+// step with rock-pro-backend/firestore.rules.
+export { ROLE_RANK, EMPTY_GRANTS, normalizeRole, roleAtLeast, effectiveRole, canView, canEdit, canManage, canManageOrg, isGuest, groupGrants, resolveAccess, } from './utils/permissions.js';
 // Configurable job CSV export, shared by rock-pro-app and rock-desktop so
 // both platforms emit identical files.
 export { ALL_EXPORT_CATEGORIES, ALL_EXPORT_MEASUREMENT_DATA_FIELDS, ALL_EXPORT_OBJECT_TYPES, DEFAULT_EXPORT_CONFIG, EXPORT_EVERYTHING_CONFIG, normalizeExportConfig, } from './export/config.js';

package/dist/server.d.ts

@@ -7,6 +7,7 @@ export * from './types/layout.js';
 export * from './types/annotation.js';
 export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
+export { ROLE_RANK, EMPTY_GRANTS, normalizeRole, roleAtLeast, effectiveRole, canView, canEdit, canManage, canManageOrg, isGuest, groupGrants, resolveAccess, type MaybeRole, type GroupedGrants, type ResolvedAccess, } from './utils/permissions.js';
 export { ALL_EXPORT_CATEGORIES, ALL_EXPORT_MEASUREMENT_DATA_FIELDS, ALL_EXPORT_OBJECT_TYPES, DEFAULT_EXPORT_CONFIG, EXPORT_EVERYTHING_CONFIG, normalizeExportConfig, type ExportCategory, type ExportConfig, type ExportImageFormat, type ExportMeasurementDataField, type ExportMeasurementFilter, type ExportObjectType, } from './export/config.js';
 export { classifyFileForExport } from './export/objectKinds.js';
 export { buildJobCsv, escapeCSVField, hyperlinkCell, type BuildJobCsvInput, type ExportObjectRow, type ExportScope, } from './export/buildJobCsv.js';

package/dist/server.js

@@ -12,6 +12,7 @@ export * from './types/layout.js';
 export * from './types/annotation.js';
 export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, } from './utils/tolerance.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
+export { ROLE_RANK, EMPTY_GRANTS, normalizeRole, roleAtLeast, effectiveRole, canView, canEdit, canManage, canManageOrg, isGuest, groupGrants, resolveAccess, } from './utils/permissions.js';
 export { ALL_EXPORT_CATEGORIES, ALL_EXPORT_MEASUREMENT_DATA_FIELDS, ALL_EXPORT_OBJECT_TYPES, DEFAULT_EXPORT_CONFIG, EXPORT_EVERYTHING_CONFIG, normalizeExportConfig, } from './export/config.js';
 export { classifyFileForExport } from './export/objectKinds.js';
 export { buildJobCsv, escapeCSVField, hyperlinkCell, } from './export/buildJobCsv.js';

package/dist/types/firestore.d.ts

@@ -21,7 +21,60 @@ export declare enum OrganizationRole {
     Admin = "admin",
     Full = "member",
     Contributor = "contributor",
-    Viewer = "viewer"
+    Viewer = "viewer",
+    /**
+     * Synthetic org membership for users invited to a single project or job.
+     * Grants read of the org doc and its supporting library (templates, labels,
+     * formulas, miter variants, print logos) and nothing under `projects/`.
+     * Server-written only; never offered in an org role picker. The same word
+     * is used for the project-level marker an `AccessGrant` carries when a user
+     * has job access but no project access — "may read this container's doc,
+     * nothing inside it".
+     */
+    Guest = "guest"
+}
+/** Roles an org admin may assign in Team settings. Excludes Guest. */
+export declare const ASSIGNABLE_ORG_ROLES: readonly OrganizationRole[];
+/**
+ * Roles grantable on a single project or job. Same wire values as the org
+ * roles minus Admin (admin is org management, not data access).
+ */
+export type ScopedRole = OrganizationRole.Full | OrganizationRole.Contributor | OrganizationRole.Viewer;
+export declare const SCOPED_ROLES: readonly ScopedRole[];
+/**
+ * What the sharing UIs offer. Contributor is deliberately absent (Figma
+ * 1028-47443 / 746-37130 show Full and Viewer); add it here to enable it —
+ * rules and types already accept it.
+ */
+export declare const ACCESS_ROLE_OPTIONS: readonly {
+    label: string;
+    value: ScopedRole;
+}[];
+/** Role stored on an `AccessGrant`: a scoped role, or the project-level guest marker. */
+export type AccessRole = ScopedRole | OrganizationRole.Guest;
+export type AccessScope = 'project' | 'job';
+/**
+ * A per-user grant on a project or a job. Lives at
+ *   organizations/{orgId}/projects/{projectId}/access/{uid}            (scope 'project')
+ *   organizations/{orgId}/projects/{projectId}/jobs/{jobId}/access/{uid} (scope 'job')
+ * Doc id == uid. Written only by Cloud Functions. Discovered by the client
+ * with `collectionGroup('access').where('userId', '==', uid)`.
+ */
+export interface AccessGrant extends FirestoreDoc {
+    userId: string;
+    organizationId: string;
+    projectId: string;
+    jobId?: string;
+    scope: AccessScope;
+    role: AccessRole;
+    email: string;
+    firstName: string;
+    lastName: string;
+    grantedBy: {
+        userId: string;
+        email: string;
+    };
+    grantedAt: Date;
 }
 export declare enum InvitationStatus {
     Pending = "pending",
@@ -49,6 +102,16 @@ export interface Invitation extends FirestoreDoc, Timestamps {
     organizationId: string;
     role: OrganizationRole;
     status: InvitationStatus;
+    /**
+     * Present on project/job invites (`kind === 'access'`); absent on org
+     * invites. `projectName` / `jobName` are denormalized for email and UI
+     * copy only — never authoritative.
+     */
+    kind?: 'organization' | 'access';
+    projectId?: string;
+    jobId?: string;
+    projectName?: string;
+    jobName?: string;
 }
 export interface OrganizationMember extends FirestoreDoc {
     email: string;

package/dist/types/firestore.js

@@ -4,7 +4,38 @@ export var OrganizationRole;
     OrganizationRole["Full"] = "member";
     OrganizationRole["Contributor"] = "contributor";
     OrganizationRole["Viewer"] = "viewer";
+    /**
+     * Synthetic org membership for users invited to a single project or job.
+     * Grants read of the org doc and its supporting library (templates, labels,
+     * formulas, miter variants, print logos) and nothing under `projects/`.
+     * Server-written only; never offered in an org role picker. The same word
+     * is used for the project-level marker an `AccessGrant` carries when a user
+     * has job access but no project access — "may read this container's doc,
+     * nothing inside it".
+     */
+    OrganizationRole["Guest"] = "guest";
 })(OrganizationRole || (OrganizationRole = {}));
+/** Roles an org admin may assign in Team settings. Excludes Guest. */
+export const ASSIGNABLE_ORG_ROLES = [
+    OrganizationRole.Admin,
+    OrganizationRole.Full,
+    OrganizationRole.Contributor,
+    OrganizationRole.Viewer,
+];
+export const SCOPED_ROLES = [
+    OrganizationRole.Full,
+    OrganizationRole.Contributor,
+    OrganizationRole.Viewer,
+];
+/**
+ * What the sharing UIs offer. Contributor is deliberately absent (Figma
+ * 1028-47443 / 746-37130 show Full and Viewer); add it here to enable it —
+ * rules and types already accept it.
+ */
+export const ACCESS_ROLE_OPTIONS = [
+    { label: 'Full', value: OrganizationRole.Full },
+    { label: 'Viewer', value: OrganizationRole.Viewer },
+];
 export var InvitationStatus;
 (function (InvitationStatus) {
     InvitationStatus["Pending"] = "pending";

package/dist/utils/permissions.d.ts

@@ -0,0 +1,63 @@
+import { OrganizationRole, type AccessGrant, type ScopedRole } from '../types/firestore.js';
+/** A role as it may arrive from Firestore: possibly legacy, possibly missing. */
+export type MaybeRole = OrganizationRole | string | null | undefined;
+export declare const ROLE_RANK: Readonly<Record<OrganizationRole, number>>;
+/**
+ * Maps a stored role string to the enum. Founder member docs written by early
+ * `cloneDemoOrganization` carry the legacy value `'creator'`, which the Cloud
+ * Functions treat as admin; normalise it the same way. Unknown values → null.
+ */
+export declare function normalizeRole(role: MaybeRole): OrganizationRole | null;
+export declare function roleAtLeast(role: MaybeRole, min: OrganizationRole): boolean;
+/**
+ * Highest role wins across the levels that enclose a document. Pass only the
+ * levels that apply: `effectiveRole(org)` for org-level resources,
+ * `effectiveRole(org, project)` for a project, `effectiveRole(org, project,
+ * job)` for anything under a job. Guest at any level is ignored. Returns null
+ * when the user holds no data-bearing role.
+ */
+export declare function effectiveRole(orgRole: MaybeRole, projectRole?: MaybeRole, jobRole?: MaybeRole): OrganizationRole | null;
+/** Viewer or better. */
+export declare const canView: (role: MaybeRole) => boolean;
+/** Contributor or better — may update existing documents. */
+export declare const canEdit: (role: MaybeRole) => boolean;
+/** Full or better — may create/delete children and manage sharing. */
+export declare const canManage: (role: MaybeRole) => boolean;
+/** Org admin — team management, org settings, deleting the org. */
+export declare const canManageOrg: (orgRole: MaybeRole) => boolean;
+export declare const isGuest: (orgRole: MaybeRole) => boolean;
+/**
+ * The grants a user holds inside ONE organization, indexed for O(1) lookup.
+ * `guestProjectIds` are projects the user may read the doc of (because they
+ * hold a job grant inside) but has no project-level role on.
+ */
+export interface GroupedGrants {
+    projectRoles: Readonly<Record<string, ScopedRole>>;
+    jobRolesByProject: Readonly<Record<string, Readonly<Record<string, ScopedRole>>>>;
+    guestProjectIds: readonly string[];
+}
+export declare const EMPTY_GRANTS: GroupedGrants;
+/**
+ * Groups the raw docs from `collectionGroup('access')` for one org. Grants for
+ * other orgs are ignored, so callers may pass the whole snapshot. A project
+ * grant with role `guest` is a marker, recorded in `guestProjectIds` only.
+ */
+export declare function groupGrants(grants: readonly Pick<AccessGrant, 'organizationId' | 'projectId' | 'jobId' | 'scope' | 'role'>[], orgId: string): GroupedGrants;
+export interface ResolvedAccess {
+    /** Effective (highest-wins) role, or null when the user has no access. */
+    role: OrganizationRole | null;
+    canView: boolean;
+    canEdit: boolean;
+    canManage: boolean;
+    /**
+     * True when the user may read the project DOCUMENT itself (org viewer+,
+     * a project role, or the guest marker). Distinct from `canView`, which
+     * covers the project's contents.
+     */
+    canReadProjectDoc: boolean;
+}
+/**
+ * Resolves what a user may do at a project or a job. Mirrors the rules:
+ *   canViewProject/Job, canContributeProject/Job, canEditProject/Job.
+ */
+export declare function resolveAccess(orgRole: MaybeRole, grants: GroupedGrants, projectId: string, jobId?: string | null): ResolvedAccess;

package/dist/utils/permissions.js

@@ -0,0 +1,131 @@
+// Role arithmetic shared by both clients and the backend. Pure: no React, no
+// Firebase, no Skia — this module is re-exported from `server.ts`.
+//
+// Three levels of access exist (organization → project → job). A user's
+// effective role on any document is the HIGHEST of the roles they hold at the
+// levels enclosing it; lower-level grants are additive and never restrict.
+// `Guest` (org role, or the project-level marker on an AccessGrant) ranks
+// below Viewer and contributes nothing to the effective role — it exists so
+// the container document itself is readable.
+//
+// The Firestore rules in rock-pro-backend/firestore.rules encode the same
+// tiers; keep the two in step:
+//   view   = Viewer+       (rules: canView*)
+//   edit   = Contributor+  (rules: canContribute*)
+//   manage = Full+         (rules: canEdit* / canManage*)
+import { OrganizationRole, } from '../types/firestore.js';
+export const ROLE_RANK = {
+    [OrganizationRole.Guest]: 0,
+    [OrganizationRole.Viewer]: 1,
+    [OrganizationRole.Contributor]: 2,
+    [OrganizationRole.Full]: 3,
+    [OrganizationRole.Admin]: 4,
+};
+const KNOWN_ROLES = new Set(Object.values(OrganizationRole));
+/**
+ * Maps a stored role string to the enum. Founder member docs written by early
+ * `cloneDemoOrganization` carry the legacy value `'creator'`, which the Cloud
+ * Functions treat as admin; normalise it the same way. Unknown values → null.
+ */
+export function normalizeRole(role) {
+    if (role == null)
+        return null;
+    if (role === 'creator')
+        return OrganizationRole.Admin;
+    return KNOWN_ROLES.has(role) ? role : null;
+}
+export function roleAtLeast(role, min) {
+    const r = normalizeRole(role);
+    return r != null && ROLE_RANK[r] >= ROLE_RANK[min];
+}
+/**
+ * Highest role wins across the levels that enclose a document. Pass only the
+ * levels that apply: `effectiveRole(org)` for org-level resources,
+ * `effectiveRole(org, project)` for a project, `effectiveRole(org, project,
+ * job)` for anything under a job. Guest at any level is ignored. Returns null
+ * when the user holds no data-bearing role.
+ */
+export function effectiveRole(orgRole, projectRole, jobRole) {
+    let best = null;
+    for (const raw of [orgRole, projectRole, jobRole]) {
+        const r = normalizeRole(raw);
+        if (r == null || r === OrganizationRole.Guest)
+            continue;
+        if (best == null || ROLE_RANK[r] > ROLE_RANK[best])
+            best = r;
+    }
+    return best;
+}
+/** Viewer or better. */
+export const canView = (role) => roleAtLeast(role, OrganizationRole.Viewer);
+/** Contributor or better — may update existing documents. */
+export const canEdit = (role) => roleAtLeast(role, OrganizationRole.Contributor);
+/** Full or better — may create/delete children and manage sharing. */
+export const canManage = (role) => roleAtLeast(role, OrganizationRole.Full);
+/** Org admin — team management, org settings, deleting the org. */
+export const canManageOrg = (orgRole) => roleAtLeast(orgRole, OrganizationRole.Admin);
+export const isGuest = (orgRole) => normalizeRole(orgRole) === OrganizationRole.Guest;
+export const EMPTY_GRANTS = Object.freeze({
+    projectRoles: Object.freeze({}),
+    jobRolesByProject: Object.freeze({}),
+    guestProjectIds: Object.freeze([]),
+});
+function isScopedRole(role) {
+    const r = normalizeRole(role);
+    return (r === OrganizationRole.Full ||
+        r === OrganizationRole.Contributor ||
+        r === OrganizationRole.Viewer);
+}
+/**
+ * Groups the raw docs from `collectionGroup('access')` for one org. Grants for
+ * other orgs are ignored, so callers may pass the whole snapshot. A project
+ * grant with role `guest` is a marker, recorded in `guestProjectIds` only.
+ */
+export function groupGrants(grants, orgId) {
+    var _a;
+    const projectRoles = {};
+    const jobRolesByProject = {};
+    const guest = new Set();
+    for (const g of grants) {
+        if (g.organizationId !== orgId)
+            continue;
+        if (g.scope === 'job') {
+            if (!g.jobId || !isScopedRole(g.role))
+                continue;
+            (jobRolesByProject[_a = g.projectId] ?? (jobRolesByProject[_a] = {}))[g.jobId] = g.role;
+        }
+        else if (g.scope === 'project') {
+            if (isScopedRole(g.role))
+                projectRoles[g.projectId] = g.role;
+            else if (normalizeRole(g.role) === OrganizationRole.Guest)
+                guest.add(g.projectId);
+        }
+    }
+    // A real project role supersedes a stale marker.
+    for (const id of Object.keys(projectRoles))
+        guest.delete(id);
+    return {
+        projectRoles,
+        jobRolesByProject,
+        guestProjectIds: [...guest].sort(),
+    };
+}
+/**
+ * Resolves what a user may do at a project or a job. Mirrors the rules:
+ *   canViewProject/Job, canContributeProject/Job, canEditProject/Job.
+ */
+export function resolveAccess(orgRole, grants, projectId, jobId) {
+    const projectRole = grants.projectRoles[projectId];
+    const jobRole = jobId
+        ? grants.jobRolesByProject[projectId]?.[jobId]
+        : undefined;
+    const role = effectiveRole(orgRole, projectRole, jobId ? jobRole : undefined);
+    return {
+        role,
+        canView: canView(role),
+        canEdit: canEdit(role),
+        canManage: canManage(role),
+        canReadProjectDoc: canView(effectiveRole(orgRole, projectRole)) ||
+            grants.guestProjectIds.includes(projectId),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.20.2",
+  "version": "1.21.0",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",

package/dist/canvas/AnnotationCanvas.d.ts

@@ -1,11 +0,0 @@
-import { type ReactNode } from 'react';
-import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.js';
-export type { AnnotationCanvasHandle, GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
-export interface CanvasKitOpts {
-    locateFile?: (file: string) => string;
-}
-export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
-    fallback?: ReactNode;
-    canvasKitOpts?: CanvasKitOpts;
-};
-export declare const AnnotationCanvas: ({ fallback, canvasKitOpts, ...rest }: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.js

@@ -1,10 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { WithSkiaWeb } from '@shopify/react-native-skia/lib/module/web/index.js';
-// Web-only entry point: lazy-loads CanvasKit wasm via WithSkiaWeb. Imperative
-// API (undo/redo/zoom) is exposed through the `imperativeRef` prop rather
-// than React refs, since WithSkiaWeb can't forward refs through its lazy
-// component boundary. The native build sits in `AnnotationCanvas.native.tsx`
-// and skips WithSkiaWeb entirely (no wasm to load).
-export const AnnotationCanvas = ({ fallback, canvasKitOpts, ...rest }) => (_jsx(WithSkiaWeb, { getComponent: () => import('./AnnotationCanvasInner.js').then((m) => ({
-        default: m.AnnotationCanvasInner,
-    })), fallback: fallback ?? null, componentProps: rest, opts: canvasKitOpts }));

package/dist/canvas/AnnotationCanvas.native.d.ts

@@ -1,8 +0,0 @@
-import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.native.js';
-export type { AnnotationCanvasHandle, } from './useAnnotationCanvasState.js';
-export type { GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
-export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
-    fallback?: unknown;
-    canvasKitOpts?: unknown;
-};
-export declare const AnnotationCanvas: (props: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.native.js

@@ -1,6 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { AnnotationCanvasInner } from './AnnotationCanvasInner.native.js';
-export const AnnotationCanvas = (props) => {
-    const { fallback: _f, canvasKitOpts: _o, ...rest } = props;
-    return _jsx(AnnotationCanvasInner, { ...rest });
-};

package/dist/canvas/AnnotationCanvasInner.d.ts

@@ -1,39 +0,0 @@
-import { type CSSProperties, type MutableRefObject } from 'react';
-import type { DecimalTolerance, FractionalTolerance, Measurement, Units } from '../types/firestore.js';
-import type { AnnotationCanvasState, AnnotationDocumentPatch, Selection } from '../types/annotation.js';
-import type { MeasurementRef } from './measurementPicker.js';
-import type { Tool } from './Tool.js';
-import { type AnnotationCanvasHandle } from './useAnnotationCanvasState.js';
-import { type ViewportState } from './viewport.js';
-import type { RenderMeasurementStamp } from './measurementStampOverlay.js';
-export type { AnnotationCanvasHandle };
-export interface AnnotationCanvasInnerProps {
-    canvas: AnnotationCanvasState;
-    onCommit(patch: AnnotationDocumentPatch): void;
-    tools: Tool[];
-    activeToolId: string;
-    selection: Selection | null;
-    onSelectionChange(selection: Selection | null): void;
-    measurements?: Measurement[];
-    fallbackUnit?: Units;
-    fractionalTolerance?: FractionalTolerance;
-    decimalTolerance?: DecimalTolerance;
-    resolveImageUrl?: (storagePath: string) => Promise<string>;
-    pickMeasurement?: () => Promise<MeasurementRef | null>;
-    renderMeasurementStamp?: RenderMeasurementStamp;
-    stampFontSource?: unknown;
-    stampValueFontSize?: number;
-    stampLabelFontSize?: number;
-    gestures?: GestureConfig;
-    width: number;
-    height: number;
-    initialViewport?: ViewportState;
-    style?: CSSProperties;
-    imperativeRef?: MutableRefObject<AnnotationCanvasHandle | null>;
-}
-export type PanTrigger = 'middleMouse' | 'rightMouse' | 'space';
-export interface GestureConfig {
-    wheel?: 'zoom' | 'pan' | 'auto';
-    panTriggers?: PanTrigger[];
-}
-export declare const AnnotationCanvasInner: (props: AnnotationCanvasInnerProps) => import("react/jsx-runtime").JSX.Element;