@reekon-tools/boldr-utils 1.20.3 → 1.21.0

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.3",
+  "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;

package/dist/canvas/AnnotationCanvasInner.js

@@ -1,219 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useFont } from '@shopify/react-native-skia';
-import { useCallback, useEffect, useRef, } from 'react';
-import { AnnotationCanvasSkia } from './AnnotationCanvasSkia.js';
-import { useAnnotationCanvasState, } from './useAnnotationCanvasState.js';
-import { STAMP_TILE_SIZE } from './stampLayout.js';
-const DEFAULT_PAN_TRIGGERS = ['middleMouse', 'space'];
-export const AnnotationCanvasInner = (props) => {
-    const { fallbackUnit, fractionalTolerance, decimalTolerance, resolveImageUrl, stampFontSource, stampValueFontSize = 14, stampLabelFontSize = 11, gestures, width, height, style, activeToolId, tools, } = props;
-    const wheelMode = gestures?.wheel ?? 'auto';
-    const panTriggers = gestures?.panTriggers ?? DEFAULT_PAN_TRIGGERS;
-    const allowSpacePan = panTriggers.includes('space');
-    const allowMiddlePan = panTriggers.includes('middleMouse');
-    const allowRightPan = panTriggers.includes('rightMouse');
-    const valueFont = useFont(stampFontSource, stampValueFontSize);
-    const labelFont = useFont(stampFontSource, stampLabelFontSize);
-    const state = useAnnotationCanvasState(props);
-    const containerRef = useRef(null);
-    const panGestureRef = useRef(null);
-    const spaceDownRef = useRef(false);
-    const activeTool = tools.find((t) => t.id === activeToolId) ?? null;
-    const toCanvasPointer = useCallback((event) => {
-        const rect = containerRef.current?.getBoundingClientRect();
-        const screen = {
-            x: event.clientX - (rect?.left ?? 0),
-            y: event.clientY - (rect?.top ?? 0),
-        };
-        return {
-            pointerId: event.pointerId,
-            screen,
-            world: state.ctx.viewport.screenToWorld(screen),
-            pressure: event.pressure || undefined,
-            shiftKey: event.shiftKey,
-            altKey: event.altKey,
-            metaKey: event.metaKey,
-            ctrlKey: event.ctrlKey,
-        };
-    }, [state.ctx.viewport]);
-    const isPanTriggerDown = useCallback((event) => {
-        if (allowMiddlePan && event.button === 1)
-            return true;
-        if (allowRightPan && event.button === 2)
-            return true;
-        if (allowSpacePan && event.button === 0 && spaceDownRef.current)
-            return true;
-        return false;
-    }, [allowMiddlePan, allowRightPan, allowSpacePan]);
-    const handlePointerDown = useCallback((event) => {
-        const rect = containerRef.current?.getBoundingClientRect();
-        const screen = {
-            x: event.clientX - (rect?.left ?? 0),
-            y: event.clientY - (rect?.top ?? 0),
-        };
-        if (isPanTriggerDown(event)) {
-            panGestureRef.current = { pointerId: event.pointerId, lastScreen: screen };
-            event.currentTarget.setPointerCapture(event.pointerId);
-            event.preventDefault();
-            return;
-        }
-        event.currentTarget.setPointerCapture(event.pointerId);
-        state.dispatchPointerDown(toCanvasPointer(event));
-    }, [state, toCanvasPointer, isPanTriggerDown]);
-    const handlePointerMove = useCallback((event) => {
-        const pan = panGestureRef.current;
-        if (pan && event.pointerId === pan.pointerId) {
-            const rect = containerRef.current?.getBoundingClientRect();
-            const screen = {
-                x: event.clientX - (rect?.left ?? 0),
-                y: event.clientY - (rect?.top ?? 0),
-            };
-            state.pan({
-                x: screen.x - pan.lastScreen.x,
-                y: screen.y - pan.lastScreen.y,
-            });
-            panGestureRef.current = { pointerId: pan.pointerId, lastScreen: screen };
-            return;
-        }
-        state.dispatchPointerMove(toCanvasPointer(event));
-    }, [state, toCanvasPointer]);
-    const handlePointerUp = useCallback((event) => {
-        const pan = panGestureRef.current;
-        if (pan && event.pointerId === pan.pointerId) {
-            panGestureRef.current = null;
-            return;
-        }
-        state.dispatchPointerUp(toCanvasPointer(event));
-    }, [state, toCanvasPointer]);
-    const handlePointerCancel = useCallback(() => {
-        panGestureRef.current = null;
-        state.dispatchPointerCancel();
-    }, [state]);
-    const handleWheel = useCallback((event) => {
-        const rect = containerRef.current?.getBoundingClientRect();
-        const focal = {
-            x: event.clientX - (rect?.left ?? 0),
-            y: event.clientY - (rect?.top ?? 0),
-        };
-        if (event.ctrlKey || event.metaKey) {
-            const factor = Math.exp(-event.deltaY / 200);
-            state.zoom(focal, state.ctx.viewport.state.zoom * factor);
-            return;
-        }
-        if (wheelMode === 'zoom') {
-            const factor = Math.exp(-event.deltaY / 300);
-            state.zoom(focal, state.ctx.viewport.state.zoom * factor);
-            return;
-        }
-        if (event.shiftKey) {
-            state.pan({ x: event.deltaY, y: event.deltaX });
-            return;
-        }
-        state.pan({ x: event.deltaX, y: event.deltaY });
-    }, [state, wheelMode]);
-    const handleContextMenu = useCallback((event) => {
-        if (allowRightPan)
-            event.preventDefault();
-    }, [allowRightPan]);
-    useEffect(() => {
-        const el = containerRef.current;
-        if (!el)
-            return;
-        const stop = (e) => {
-            if (e.target === el || el.contains(e.target)) {
-                e.preventDefault();
-            }
-        };
-        el.addEventListener('wheel', stop, { passive: false });
-        return () => el.removeEventListener('wheel', stop);
-    }, []);
-    useEffect(() => {
-        if (!allowSpacePan)
-            return;
-        const onKeyDown = (e) => {
-            if (e.code === 'Space' && !e.repeat) {
-                spaceDownRef.current = true;
-                if (containerRef.current)
-                    containerRef.current.style.cursor = 'grab';
-            }
-        };
-        const onKeyUp = (e) => {
-            if (e.code === 'Space') {
-                spaceDownRef.current = false;
-                if (containerRef.current)
-                    containerRef.current.style.cursor = '';
-            }
-        };
-        window.addEventListener('keydown', onKeyDown);
-        window.addEventListener('keyup', onKeyUp);
-        return () => {
-            window.removeEventListener('keydown', onKeyDown);
-            window.removeEventListener('keyup', onKeyUp);
-        };
-    }, [allowSpacePan]);
-    const containerStyle = {
-        position: 'relative',
-        width,
-        height,
-        overflow: 'hidden',
-        touchAction: 'none',
-        userSelect: 'none',
-        cursor: activeTool?.cursor ?? 'default',
-        ...style,
-    };
-    const customPreview = activeTool?.renderPreview?.(state.customPreviewState, state.ctx);
-    const { renderMeasurementStamp, selection } = props;
-    return (_jsxs("div", { ref: containerRef, style: containerStyle, onPointerDown: handlePointerDown, onPointerMove: handlePointerMove, onPointerUp: handlePointerUp, onPointerCancel: handlePointerCancel, onWheel: handleWheel, onContextMenu: handleContextMenu, children: [AnnotationCanvasSkia({
-                width,
-                height,
-                effectiveCanvas: state.effectiveCanvas,
-                worldTransform: state.worldTransform,
-                measurementsById: state.measurementsById,
-                fallbackUnit,
-                fractionalTolerance,
-                decimalTolerance,
-                resolveImageUrl,
-                valueFont,
-                labelFont,
-                hideMeasurementStamps: !!renderMeasurementStamp,
-                penDrawingStroke: state.penDrawingStroke,
-                customPreview,
-            }), renderMeasurementStamp && (_jsx("div", { style: {
-                    position: 'absolute',
-                    inset: 0,
-                    pointerEvents: 'none',
-                }, children: state.effectiveCanvas.placedMeasurements.map((placed) => {
-                    const size = STAMP_TILE_SIZE * (placed.scale ?? 1);
-                    const cx = (placed.anchor.x - state.viewport.pan.x) * state.viewport.zoom;
-                    const cy = (placed.anchor.y - state.viewport.pan.y) * state.viewport.zoom;
-                    const isSelected = selection?.ids.includes(placed.id) ?? false;
-                    return (_jsxs("div", { style: {
-                            position: 'absolute',
-                            left: 0,
-                            top: 0,
-                            width: size,
-                            height: size,
-                            transform: `translate(${cx - size / 2}px, ${cy - size / 2}px)`,
-                        }, children: [renderMeasurementStamp({
-                                placed,
-                                measurement: state.measurementsById.get(placed.measurementId) ?? null,
-                                selected: isSelected,
-                                size,
-                                zoom: state.viewport.zoom,
-                            }), isSelected && (_jsx("div", { role: "button", "aria-label": "Remove measurement", onPointerDown: (e) => {
-                                    e.stopPropagation();
-                                    state.ctx.commit({
-                                        ops: [{ op: 'removeMeasurement', id: placed.id }],
-                                    });
-                                    state.ctx.setSelection(null);
-                                }, style: {
-                                    position: 'absolute',
-                                    top: -10,
-                                    right: -10,
-                                    width: 40,
-                                    height: 40,
-                                    cursor: 'pointer',
-                                    pointerEvents: 'auto',
-                                } }))] }, placed.id));
-                }) }))] }));
-};