@reekon-tools/boldr-utils 1.7.4 → 1.8.0

package/dist/calculator/categories.d.ts

@@ -0,0 +1,76 @@
+import type { CalculatorDefinition } from './schema.js';
+/**
+ * Category ids, as PERSISTED on `calculators/{id}.category`.
+ *
+ * Never rename a value — it is stored data. To retire a category, delete its
+ * entry from CALCULATOR_CATEGORIES and leave existing docs alone: they resolve
+ * to `undefined` and degrade into the "Other" bucket rather than breaking.
+ */
+export declare enum CalculatorCategoryId {
+    AreaAndVolume = "areaAndVolume",
+    Concrete = "concrete",
+    Electrical = "electrical",
+    Stairs = "stairs",
+    Framing = "framing",
+    FinishCarpentry = "finishCarpentry",
+    Hardscaping = "hardscaping",
+    Roofing = "roofing",
+    HVAC = "hvac",
+    Landscaping = "landscaping",
+    MaterialEstimator = "materialEstimator",
+    Optimizers = "optimizers",
+    Plumbing = "plumbing"
+}
+export interface CalculatorCategory {
+    id: CalculatorCategoryId;
+    /** Display label: the editor dropdown row AND the mobile category screen title. */
+    name: string;
+    /**
+     * Tile-glyph tint from the design. Uppercase 6-digit hex.
+     *
+     * This is the source of truth for the color: the icon generator bakes it
+     * into the per-app SVGs (see scripts/gen-category-icons.mjs), so a color
+     * change here needs a regenerate to reach the apps.
+     */
+    color: string;
+    /**
+     * Glyph name in the legacy ROCK app's IcoMoon set, which is where this
+     * artwork comes from. Consumed only by the icon generator — clients load the
+     * emitted SVG by category id.
+     */
+    glyph: string;
+}
+/**
+ * Canonical order, matching the design's tile grid.
+ *
+ * This array IS the ordering — there is deliberately no `sortIndex` field for
+ * it to drift out of sync with.
+ */
+export declare const CALCULATOR_CATEGORIES: readonly CalculatorCategory[];
+export declare const CALCULATOR_CATEGORY_BY_ID: Readonly<Record<CalculatorCategoryId, CalculatorCategory>>;
+/**
+ * Bucket key / route segment for calculators with no category, or with one
+ * that no longer exists. NOT a CalculatorCategoryId — guarded by a unit test,
+ * because a collision would silently swallow a real category.
+ */
+export declare const UNCATEGORIZED_CATEGORY_ID = "uncategorized";
+export declare const UNCATEGORIZED_CATEGORY_NAME = "Other";
+export type CalculatorCategoryBucketId = CalculatorCategoryId | typeof UNCATEGORIZED_CATEGORY_ID;
+export declare const isCalculatorCategoryId: (value: unknown) => value is CalculatorCategoryId;
+/**
+ * Resolve a stored category value. Returns undefined for missing, null, and
+ * retired ids — callers should treat all three as "Other" rather than trusting
+ * the raw field.
+ */
+export declare const findCalculatorCategory: (value: string | null | undefined) => CalculatorCategory | undefined;
+export declare const calculatorCategoryOf: (calculator: Pick<CalculatorDefinition, "category">) => CalculatorCategory | undefined;
+/** Display label for a stored value, falling back to "Other". */
+export declare const calculatorCategoryName: (value: string | null | undefined) => string;
+/**
+ * Group calculators by category id, collecting anything missing or
+ * unresolvable under UNCATEGORIZED_CATEGORY_ID.
+ *
+ * Keys exist only for non-empty buckets, which is what lets the mobile grid
+ * hide empty categories without a second pass.
+ */
+export declare const groupCalculatorsByCategory: <T extends Pick<CalculatorDefinition, "category">>(calculators: readonly T[]) => Map<CalculatorCategoryBucketId, T[]>;

package/dist/calculator/categories.js

@@ -0,0 +1,160 @@
+// ---------------------------------------------------------------------------
+// Calculator categories — the hard-coded taxonomy used to group published
+// calculators in the mobile catalog and to label them in the web authoring
+// tool.
+//
+// Deliberately NOT a Firestore collection: the set is authored here and ships
+// inside the package, so both clients render the same list with no extra read,
+// no rules surface, and no offline story to maintain.
+//
+// Distinct from `CalculatorDefinition.folderId`, which predates this and is
+// still unused — `folderId` implies a hierarchy, a category is flat.
+// ---------------------------------------------------------------------------
+/**
+ * Category ids, as PERSISTED on `calculators/{id}.category`.
+ *
+ * Never rename a value — it is stored data. To retire a category, delete its
+ * entry from CALCULATOR_CATEGORIES and leave existing docs alone: they resolve
+ * to `undefined` and degrade into the "Other" bucket rather than breaking.
+ */
+export var CalculatorCategoryId;
+(function (CalculatorCategoryId) {
+    CalculatorCategoryId["AreaAndVolume"] = "areaAndVolume";
+    CalculatorCategoryId["Concrete"] = "concrete";
+    CalculatorCategoryId["Electrical"] = "electrical";
+    CalculatorCategoryId["Stairs"] = "stairs";
+    CalculatorCategoryId["Framing"] = "framing";
+    CalculatorCategoryId["FinishCarpentry"] = "finishCarpentry";
+    CalculatorCategoryId["Hardscaping"] = "hardscaping";
+    CalculatorCategoryId["Roofing"] = "roofing";
+    CalculatorCategoryId["HVAC"] = "hvac";
+    CalculatorCategoryId["Landscaping"] = "landscaping";
+    CalculatorCategoryId["MaterialEstimator"] = "materialEstimator";
+    CalculatorCategoryId["Optimizers"] = "optimizers";
+    CalculatorCategoryId["Plumbing"] = "plumbing";
+})(CalculatorCategoryId || (CalculatorCategoryId = {}));
+/**
+ * Canonical order, matching the design's tile grid.
+ *
+ * This array IS the ordering — there is deliberately no `sortIndex` field for
+ * it to drift out of sync with.
+ */
+export const CALCULATOR_CATEGORIES = [
+    {
+        id: CalculatorCategoryId.AreaAndVolume,
+        name: 'Area and Volume',
+        color: '#FF3A6E',
+        glyph: 'shape_calculator',
+    },
+    {
+        id: CalculatorCategoryId.Concrete,
+        name: 'Concrete',
+        color: '#E2AB6B',
+        glyph: 'concrete',
+    },
+    {
+        id: CalculatorCategoryId.Electrical,
+        name: 'Electrical',
+        color: '#60D8FE',
+        glyph: 'electrical',
+    },
+    {
+        id: CalculatorCategoryId.Stairs,
+        name: 'Stairs',
+        color: '#D09C9C',
+        glyph: 'stair_tread',
+    },
+    {
+        id: CalculatorCategoryId.Framing,
+        name: 'Framing',
+        color: '#FABC61',
+        glyph: 'frame',
+    },
+    {
+        id: CalculatorCategoryId.FinishCarpentry,
+        name: 'Finish Carpentry',
+        color: '#2E9E82',
+        glyph: 'finish_carpentry',
+    },
+    {
+        id: CalculatorCategoryId.Hardscaping,
+        name: 'Hardscaping',
+        color: '#6B77E2',
+        glyph: 'hardscaping',
+    },
+    {
+        id: CalculatorCategoryId.Roofing,
+        name: 'Roofing',
+        color: '#E48787',
+        glyph: 'roofing',
+    },
+    {
+        id: CalculatorCategoryId.HVAC,
+        name: 'HVAC',
+        color: '#FEF260',
+        glyph: 'hvac',
+    },
+    {
+        id: CalculatorCategoryId.Landscaping,
+        name: 'Landscaping',
+        color: '#C892FF',
+        glyph: 'landscaping',
+    },
+    {
+        id: CalculatorCategoryId.MaterialEstimator,
+        name: 'Material Estimator',
+        color: '#FFAD00',
+        glyph: 'raw_materials',
+    },
+    {
+        id: CalculatorCategoryId.Optimizers,
+        name: 'Optimizers',
+        color: '#CA5726',
+        glyph: 'wall',
+    },
+    {
+        id: CalculatorCategoryId.Plumbing,
+        name: 'Plumbing',
+        color: '#008EFD',
+        glyph: 'plumbing',
+    },
+];
+export const CALCULATOR_CATEGORY_BY_ID = Object.fromEntries(CALCULATOR_CATEGORIES.map((category) => [category.id, category]));
+/**
+ * Bucket key / route segment for calculators with no category, or with one
+ * that no longer exists. NOT a CalculatorCategoryId — guarded by a unit test,
+ * because a collision would silently swallow a real category.
+ */
+export const UNCATEGORIZED_CATEGORY_ID = 'uncategorized';
+export const UNCATEGORIZED_CATEGORY_NAME = 'Other';
+export const isCalculatorCategoryId = (value) => typeof value === 'string' && value in CALCULATOR_CATEGORY_BY_ID;
+/**
+ * Resolve a stored category value. Returns undefined for missing, null, and
+ * retired ids — callers should treat all three as "Other" rather than trusting
+ * the raw field.
+ */
+export const findCalculatorCategory = (value) => isCalculatorCategoryId(value) ? CALCULATOR_CATEGORY_BY_ID[value] : undefined;
+export const calculatorCategoryOf = (calculator) => findCalculatorCategory(calculator.category);
+/** Display label for a stored value, falling back to "Other". */
+export const calculatorCategoryName = (value) => findCalculatorCategory(value)?.name ?? UNCATEGORIZED_CATEGORY_NAME;
+/**
+ * Group calculators by category id, collecting anything missing or
+ * unresolvable under UNCATEGORIZED_CATEGORY_ID.
+ *
+ * Keys exist only for non-empty buckets, which is what lets the mobile grid
+ * hide empty categories without a second pass.
+ */
+export const groupCalculatorsByCategory = (calculators) => {
+    const buckets = new Map();
+    for (const calculator of calculators) {
+        const key = isCalculatorCategoryId(calculator.category)
+            ? calculator.category
+            : UNCATEGORIZED_CATEGORY_ID;
+        const bucket = buckets.get(key);
+        if (bucket)
+            bucket.push(calculator);
+        else
+            buckets.set(key, [calculator]);
+    }
+    return buckets;
+};

package/dist/calculator/index.d.ts

@@ -1,4 +1,5 @@
 export * from './schema.js';
+export * from './categories.js';
 export * from './units.js';
 export * from './evaluate.js';
 export * from './solve.js';

package/dist/calculator/index.js

@@ -3,6 +3,7 @@
 // definition validation. Pure logic (mathjs + zod only — no Skia/React), safe
 // on web, native, and Node.
 export * from './schema.js';
+export * from './categories.js';
 export * from './units.js';
 export * from './evaluate.js';
 export * from './solve.js';

package/dist/calculator/schema.d.ts

@@ -1,5 +1,6 @@
 import { ColumnType, type ColumnConfig, type ConversionTableColumnData, type InstructionsColumnData, type SelectColumnData, type DecimalTolerance, type FractionalTolerance } from '../types/firestore.js';
 import type { AngleUnit, CalculatorUnit, FieldDimension, MeasurementDimension } from './units.js';
+import type { CalculatorCategoryId } from './categories.js';
 /**
  * Version of the definition format itself. Bumped only on breaking schema
  * changes; independent of the npm package version and of each calculator's
@@ -123,6 +124,17 @@ export interface CalculatorDefinition {
     name: string;
     description: string;
     folderId: string | null;
+    /**
+     * Hard-coded category (see categories.ts) driving the mobile category grid
+     * and the web library badge.
+     *
+     * AUTHORING METADATA ONLY — never needed to run a calculator, so it stays
+     * optional and nullable: docs authored before categories existed have no
+     * value and must keep validating. Always resolve through
+     * findCalculatorCategory() rather than comparing the raw field, so a retired
+     * id degrades to "Other" instead of vanishing.
+     */
+    category?: CalculatorCategoryId | null;
     /** Inputs + outputs in one list, discriminated by `role`. */
     fields: CalculatorField[];
     equations: CalculatorEquation[];

package/dist/calculator/schema.js

@@ -122,6 +122,9 @@ export const createEmptyCalculatorDefinition = (id) => ({
     name: '',
     description: '',
     folderId: null,
+    // `null`, never undefined — this object is spread straight into setDoc and
+    // Firestore rejects undefined field values.
+    category: null,
     fields: [],
     equations: [],
     diagramFileId: null,

package/dist/calculator/validate.d.ts

@@ -7,6 +7,7 @@ export declare const calculatorDefinitionSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     folderId: z.ZodNullable<z.ZodString>;
+    category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<ColumnType.Number>;
         defaultValue: z.ZodOptional<z.ZodNumber>;

package/dist/calculator/validate.js

@@ -3,6 +3,7 @@ import { create, all } from 'mathjs';
 import { ColumnType, DecimalTolerance, FractionalTolerance, } from '../types/firestore.js';
 import { CALCULATOR_SCHEMA_VERSION, equationForField, isEquationTargetKind, isNumericFieldKind, } from './schema.js';
 import { CALCULATOR_UNIT_INFO, unitDimension } from './units.js';
+import { isCalculatorCategoryId } from './categories.js';
 const math = create(all);
 // ---------------------------------------------------------------------------
 // Definition validation: zod for structure, plus the cross-field invariants
@@ -101,6 +102,14 @@ export const calculatorDefinitionSchema = z.object({
     name: z.string(),
     description: z.string(),
     folderId: z.string().nullable(),
+    // Deliberately z.string(), NOT z.enum(CalculatorCategoryId): a safeParse
+    // failure returns early below, so a retired or typo'd id would suppress
+    // every other invariant and mark the whole calculator broken. Unknown ids
+    // are reported further down as an advisory warning instead.
+    //
+    // The key must be listed even though it's optional — zod strips unknown
+    // keys, so omitting it here would make the check below never fire.
+    category: z.string().nullish(),
     fields: z.array(calculatorFieldSchema),
     equations: z.array(calculatorEquationSchema),
     diagramFileId: z.string().nullable().optional(),
@@ -187,6 +196,12 @@ export const validateCalculatorDefinition = (input) => {
     if (def.schemaVersion > CALCULATOR_SCHEMA_VERSION) {
         push('schema-version-unsupported', 'schemaVersion', `schemaVersion ${def.schemaVersion} is newer than this client supports (${CALCULATOR_SCHEMA_VERSION})`);
     }
+    // A category the client doesn't know is a labelling problem, not a broken
+    // calculator — an older app build reading a newly-added category must still
+    // run it. Warning severity keeps `ok` true.
+    if (def.category != null && !isCalculatorCategoryId(def.category)) {
+        push('unknown-category', 'category', `Category "${def.category}" is not a known calculator category`, 'warning');
+    }
     // --- Unique ids ---------------------------------------------------------
     const fieldIds = new Set();
     def.fields.forEach((field, i) => {

package/dist/export/buildJobCsv.d.ts

@@ -0,0 +1,26 @@
+import { type DecimalTolerance, type Formula, type FractionalTolerance, type Group, type Measurement, type Section, type Units } from '../types/firestore.js';
+import type { ExportConfig } from './config.js';
+export type ExportScope = 'all' | 'activeGroup';
+export type ExportObjectRow = {
+    name: string;
+    url: string | null;
+};
+export type BuildJobCsvInput = {
+    scope: ExportScope;
+    activeGroupId?: string | null;
+    config: ExportConfig;
+    groups: Group[];
+    sections: Section[];
+    formulas: Formula[];
+    measurementsByGroup: Map<string, Measurement[]>;
+    objectsByGroup: Map<string, ExportObjectRow[]>;
+    formatMeasurementValue: (value: number, device?: string) => string;
+    unitPrefs: {
+        defaultUnit?: Units;
+        fractionalTolerance?: FractionalTolerance;
+        decimalTolerance?: DecimalTolerance;
+    };
+};
+export declare const escapeCSVField: (field: string) => string;
+export declare const hyperlinkCell: (url: string, label: string) => string;
+export declare function buildJobCsv(input: BuildJobCsvInput): string;

package/dist/export/buildJobCsv.js

@@ -0,0 +1,189 @@
+import { ColumnType, GroupType, } from '../types/firestore.js';
+import { calculateFormula } from '../formulas/calculateFormula.js';
+import { formatSelectedValues } from '../utils/selectValues.js';
+import { isDefaultGroup, isFormGroupCompleted } from '../utils/groups.js';
+export const escapeCSVField = (field) => `"${field.replace(/"/g, '""')}"`;
+// Spreadsheet-formula hyperlink cell. Two escaping layers: quotes inside the
+// formula's string literals are doubled (Excel/Sheets escaping), then the
+// whole formula is CSV-escaped.
+export const hyperlinkCell = (url, label) => escapeCSVField(`=HYPERLINK("${url.replace(/"/g, '""')}","${label.replace(/"/g, '""')}")`);
+const objectCell = (obj) => obj.url ? hyperlinkCell(obj.url, obj.name) : escapeCSVField(obj.name);
+// Pure CSV assembly for the job export, shared by rock-pro-app and
+// rock-desktop so the two platforms emit identical files. With no objects
+// selected and all measurement-data columns on, the measurement sections are
+// identical to the legacy exportCSV output; objects add a trailing "Objects"
+// column (list groups) or extend the form row (form groups), one skipped
+// column after the existing cells.
+export function buildJobCsv(input) {
+    const { scope, activeGroupId, config, groups, sections, formulas, measurementsByGroup, objectsByGroup, formatMeasurementValue, unitPrefs, } = input;
+    const csvRows = [];
+    let listGroups;
+    let formGroups;
+    if (scope === 'activeGroup') {
+        const active = groups.find((g) => g.id === activeGroupId);
+        listGroups = active?.type === GroupType.LIST ? [active] : [];
+        formGroups = active?.type === GroupType.FORM ? [active] : [];
+    }
+    else {
+        listGroups = groups.filter((g) => g.type === GroupType.LIST &&
+            config.categories.includes(isDefaultGroup(g) ? 'defaultGroup' : 'groups'));
+        formGroups = config.categories.includes('forms')
+            ? groups.filter((g) => g.type === GroupType.FORM)
+            : [];
+    }
+    const measurementPassesFilter = (m) => config.measurements === 'all' ||
+        (config.measurements === 'complete'
+            ? m.isCompleted === true
+            : m.isCompleted !== true);
+    const includeField = (field) => config.measurementData.includes(field);
+    // --- List Groups ---
+    if (listGroups.length > 0) {
+        csvRows.push('List Groups');
+        csvRows.push('');
+        listGroups.forEach((group) => {
+            csvRows.push(`Group: ${group.name}`);
+            const objects = objectsByGroup.get(group.id) ?? [];
+            const headerCells = [
+                '',
+                ...(includeField('measurement') ? ['Measurement'] : []),
+                ...(includeField('label') ? ['Label'] : []),
+                ...(includeField('notes') ? ['Notes'] : []),
+            ].map(escapeCSVField);
+            if (objects.length > 0) {
+                headerCells.push(escapeCSVField(''), escapeCSVField('Objects'));
+            }
+            csvRows.push(headerCells.join(','));
+            const measurements = (measurementsByGroup.get(group.id) ?? []).filter(measurementPassesFilter);
+            // Objects fill a parallel column, one per row from the top; extra rows
+            // are emitted when a group has more objects than measurements.
+            const rowCount = Math.max(measurements.length, objects.length);
+            for (let i = 0; i < rowCount; i++) {
+                const measurement = measurements[i];
+                const row = [escapeCSVField('')];
+                if (includeField('measurement')) {
+                    row.push(escapeCSVField(measurement
+                        ? formatMeasurementValue(measurement.value, measurement.device)
+                        : ''));
+                }
+                if (includeField('label')) {
+                    row.push(escapeCSVField(measurement?.label || ''));
+                }
+                if (includeField('notes')) {
+                    row.push(escapeCSVField(measurement?.note || ''));
+                }
+                const obj = objects[i];
+                if (obj) {
+                    row.push(escapeCSVField(''), objectCell(obj));
+                }
+                csvRows.push(row.join(','));
+            }
+            csvRows.push('');
+        });
+    }
+    // --- Form Groups ---
+    if (formGroups.length > 0) {
+        csvRows.push('Form Groups');
+        csvRows.push('');
+        const sectionIds = [...new Set(formGroups.map((g) => g.sectionId))];
+        sectionIds.forEach((sectionId) => {
+            const section = sections.find((s) => s.id === sectionId);
+            if (!section)
+                return;
+            const sectionGroups = formGroups.filter((g) => g.sectionId === sectionId);
+            if (sectionGroups.length === 0)
+                return;
+            csvRows.push(`Section: ${section.name}`);
+            csvRows.push('');
+            const columnHeaders = [];
+            section.tableConfig.forEach((column) => {
+                columnHeaders.push(column.name);
+                if (column.type === ColumnType.Measurement ||
+                    column.type === ColumnType.Angle) {
+                    columnHeaders.push(`${column.name} Notes`);
+                }
+            });
+            csvRows.push(['Form Name', ...columnHeaders].map(escapeCSVField).join(','));
+            sectionGroups.forEach((group) => {
+                // The completeness filter drops whole rows (their objects with
+                // them); cell references below still resolve against the group's
+                // full measurement list.
+                if (config.measurements !== 'all') {
+                    const completed = isFormGroupCompleted(group, section);
+                    if (config.measurements === 'complete' ? !completed : completed) {
+                        return;
+                    }
+                }
+                const row = [];
+                section.tableConfig.forEach((column) => {
+                    if (column.type === ColumnType.Formula) {
+                        const formula = formulas.find((f) => f.id === column.columnData?.formulaId);
+                        if (formula) {
+                            try {
+                                const result = calculateFormula(formula, formulas, group.columns, section.tableConfig, measurementsByGroup.get(group.id) ?? [], unitPrefs.defaultUnit, unitPrefs.fractionalTolerance, unitPrefs.decimalTolerance);
+                                if (result !== null &&
+                                    result !== undefined &&
+                                    typeof result === 'number') {
+                                    row.push(escapeCSVField(formatMeasurementValue(result)));
+                                }
+                                else {
+                                    row.push(escapeCSVField(result !== null && result !== undefined
+                                        ? String(result)
+                                        : ''));
+                                }
+                            }
+                            catch {
+                                row.push('');
+                            }
+                        }
+                        else {
+                            row.push('');
+                        }
+                    }
+                    else if (column.type === ColumnType.Angle) {
+                        const measurementId = group.columns[column.id];
+                        const measurements = measurementsByGroup.get(group.id);
+                        const measurement = measurements?.find((m) => m.id === measurementId);
+                        if (measurement) {
+                            row.push(escapeCSVField(`${measurement.value}°`));
+                        }
+                        else {
+                            row.push(escapeCSVField(formatSelectedValues(group.columns[column.id])));
+                        }
+                    }
+                    else if (column.id in group.columns) {
+                        const measurementId = group.columns[column.id];
+                        const measurements = measurementsByGroup.get(group.id);
+                        const measurement = measurements?.find((m) => m.id === measurementId);
+                        if (measurement) {
+                            row.push(escapeCSVField(formatMeasurementValue(measurement.value, measurement.device)));
+                        }
+                        else {
+                            row.push(escapeCSVField(formatSelectedValues(group.columns[column.id])));
+                        }
+                    }
+                    else {
+                        row.push('');
+                    }
+                    if (column.type === ColumnType.Measurement ||
+                        column.type === ColumnType.Angle) {
+                        if (group.descriptions && group.descriptions[column.id]) {
+                            row.push(escapeCSVField(group.descriptions[column.id]));
+                        }
+                        else {
+                            row.push('');
+                        }
+                    }
+                });
+                // Objects extend the row past the table, one skipped column after
+                // the last cell.
+                const objects = objectsByGroup.get(group.id) ?? [];
+                if (objects.length > 0) {
+                    row.push(escapeCSVField(''), ...objects.map(objectCell));
+                }
+                csvRows.push([escapeCSVField(group.name), ...row].join(','));
+            });
+            csvRows.push('');
+        });
+    }
+    return csvRows.join('\n');
+}

package/dist/export/config.d.ts

@@ -0,0 +1,18 @@
+export type ExportCategory = 'defaultGroup' | 'groups' | 'forms';
+export type ExportObjectType = 'calculators' | 'files' | 'photos' | 'cad' | 'labels' | 'notes';
+export type ExportMeasurementFilter = 'all' | 'complete' | 'incomplete';
+export type ExportImageFormat = 'hyperlink' | 'none';
+export type ExportMeasurementDataField = 'measurement' | 'label' | 'notes';
+export type ExportConfig = {
+    categories: ExportCategory[];
+    objects: ExportObjectType[];
+    measurements: ExportMeasurementFilter;
+    imageFormat: ExportImageFormat;
+    measurementData: ExportMeasurementDataField[];
+};
+export declare const ALL_EXPORT_CATEGORIES: ExportCategory[];
+export declare const ALL_EXPORT_OBJECT_TYPES: ExportObjectType[];
+export declare const ALL_EXPORT_MEASUREMENT_DATA_FIELDS: ExportMeasurementDataField[];
+export declare const DEFAULT_EXPORT_CONFIG: ExportConfig;
+export declare const EXPORT_EVERYTHING_CONFIG: ExportConfig;
+export declare function normalizeExportConfig(raw: unknown): ExportConfig;

package/dist/export/config.js

@@ -0,0 +1,72 @@
+// Shared model for the configurable job CSV export (rock-pro-app +
+// rock-desktop). The config is persisted on the user doc (`exportConfig`) so
+// it follows the user across devices and platforms; both apps must therefore
+// read/write the same shape and tolerate values written by the other.
+export const ALL_EXPORT_CATEGORIES = [
+    'defaultGroup',
+    'groups',
+    'forms',
+];
+export const ALL_EXPORT_OBJECT_TYPES = [
+    'calculators',
+    'files',
+    'photos',
+    'cad',
+    'labels',
+    'notes',
+];
+export const ALL_EXPORT_MEASUREMENT_DATA_FIELDS = ['measurement', 'label', 'notes'];
+// Objects are opt-in: nothing ticked and images excluded until the user
+// configures otherwise, so a default export is measurements-only.
+export const DEFAULT_EXPORT_CONFIG = {
+    categories: [...ALL_EXPORT_CATEGORIES],
+    objects: [],
+    measurements: 'all',
+    imageFormat: 'none',
+    measurementData: [...ALL_EXPORT_MEASUREMENT_DATA_FIELDS],
+};
+// "Export All" (everything, ignoring the saved config): every category, every
+// object kind as a hyperlink, all measurements, all list columns.
+export const EXPORT_EVERYTHING_CONFIG = {
+    categories: [...ALL_EXPORT_CATEGORIES],
+    objects: [...ALL_EXPORT_OBJECT_TYPES],
+    measurements: 'all',
+    imageFormat: 'hyperlink',
+    measurementData: [...ALL_EXPORT_MEASUREMENT_DATA_FIELDS],
+};
+const isCategory = (v) => typeof v === 'string' && ALL_EXPORT_CATEGORIES.includes(v);
+const isObjectType = (v) => typeof v === 'string' && ALL_EXPORT_OBJECT_TYPES.includes(v);
+const isMeasurementFilter = (v) => v === 'all' || v === 'complete' || v === 'incomplete';
+const isImageFormat = (v) => v === 'hyperlink' || v === 'none';
+const isMeasurementDataField = (v) => typeof v === 'string' &&
+    ALL_EXPORT_MEASUREMENT_DATA_FIELDS.includes(v);
+// Tolerant reader for the raw user-doc field. Missing/invalid fields fall
+// back to defaults and unknown array members are dropped. Empty `categories`
+// or `measurementData` fall back to all — the UIs can't save those, so treat
+// them as corrupt. `objects` defaults to none (objects are opt-in), so
+// missing and empty read the same.
+export function normalizeExportConfig(raw) {
+    const r = raw && typeof raw === 'object' ? raw : {};
+    const categories = Array.isArray(r.categories)
+        ? r.categories.filter(isCategory)
+        : [];
+    const objects = Array.isArray(r.objects)
+        ? r.objects.filter(isObjectType)
+        : [];
+    const measurementData = Array.isArray(r.measurementData)
+        ? r.measurementData.filter(isMeasurementDataField)
+        : [];
+    return {
+        categories: categories.length > 0 ? categories : [...ALL_EXPORT_CATEGORIES],
+        objects,
+        measurements: isMeasurementFilter(r.measurements)
+            ? r.measurements
+            : DEFAULT_EXPORT_CONFIG.measurements,
+        imageFormat: isImageFormat(r.imageFormat)
+            ? r.imageFormat
+            : DEFAULT_EXPORT_CONFIG.imageFormat,
+        measurementData: measurementData.length > 0
+            ? measurementData
+            : [...ALL_EXPORT_MEASUREMENT_DATA_FIELDS],
+    };
+}

package/dist/export/desktopLinks.d.ts

@@ -0,0 +1,11 @@
+import { type FileUpload } from '../types/firestore.js';
+export type DesktopLinkContext = {
+    baseUrl: string;
+    orgId: string;
+    projectId: string;
+    jobId: string;
+    groupId: string;
+    isDefaultGroup: boolean;
+};
+export declare function desktopBaseUrlForFirebaseProject(firebaseProjectId: string | undefined): string;
+export declare function desktopFileEditorUrl(file: FileUpload, ctx: DesktopLinkContext): string | null;

package/dist/export/desktopLinks.js

@@ -0,0 +1,45 @@
+import { FileUploadType } from '../types/firestore.js';
+// Maps the running mobile app's Firebase project onto the desktop
+// deployment. Dev builds target a local rock-desktop dev server (`yarn dev`,
+// Vite's default port) for testing.
+export function desktopBaseUrlForFirebaseProject(firebaseProjectId) {
+    switch (firebaseProjectId) {
+        case 'rock-production-pro':
+            return 'https://app.boldrpro.com';
+        case 'rock-staging-pro':
+            return 'https://staging.app.boldrpro.com';
+        default:
+            return 'http://localhost:5173';
+    }
+}
+// Returns the desktop editor URL for an exported group file, or null when
+// desktop has no editor for it (labels render inert there) — the CSV cell
+// then degrades to the plain object name.
+export function desktopFileEditorUrl(file, ctx) {
+    const { baseUrl, orgId, projectId, jobId, groupId, isDefaultGroup } = ctx;
+    const jobPath = `${baseUrl}/app/organizations/${orgId}/projects/${projectId}/jobs/${jobId}`;
+    const groupQuery = `groupId=${encodeURIComponent(groupId)}`;
+    switch (file.type) {
+        case FileUploadType.LayoutGroup:
+            return `${jobPath}/layout-group/${file.id}?${groupQuery}`;
+        case FileUploadType.Note:
+            return `${jobPath}/notes/${file.id}?${groupQuery}`;
+        case FileUploadType.Canvas:
+            return `${jobPath}/canvas/${file.id}?${groupQuery}`;
+        case FileUploadType.Annotation: {
+            // Pass a top-level fileType through when the doc carries one (desktop
+            // uses it to pick the 3D viewer); omit otherwise — the viewer defaults
+            // to the PDF path.
+            const rawFileType = file.fileType;
+            const fileTypeQuery = rawFileType
+                ? `&fileType=${encodeURIComponent(rawFileType)}`
+                : '';
+            const defaultQuery = isDefaultGroup ? '&isDefault=true' : '';
+            return `${jobPath}/viewer?fileId=${encodeURIComponent(file.id)}&${groupQuery}${fileTypeQuery}${defaultQuery}`;
+        }
+        default:
+            // Labels (no desktop editor) and anything classifyFileForExport should
+            // already have excluded.
+            return null;
+    }
+}

package/dist/export/objectKinds.d.ts

@@ -0,0 +1,3 @@
+import { type FileUpload } from '../types/firestore.js';
+import type { ExportObjectType } from './config.js';
+export declare function classifyFileForExport(file: FileUpload): ExportObjectType | null;

package/dist/export/objectKinds.js

@@ -0,0 +1,28 @@
+import { FileUploadType } from '../types/firestore.js';
+// Maps a group file onto the export config's object kinds. `null` means the
+// file is never exported: Calculator is a config placeholder for now (the
+// checkbox persists but nothing exports until calculator export ships),
+// Conversion/Template/Background are internal utility docs, and Annotation
+// files flagged `isLabel` are label-print artifacts hidden from group grids.
+export function classifyFileForExport(file) {
+    switch (file.type) {
+        case FileUploadType.LayoutGroup:
+            return 'cad';
+        case FileUploadType.Note:
+            return 'notes';
+        case FileUploadType.Label:
+            return 'labels';
+        case FileUploadType.Canvas:
+            return 'photos';
+        case FileUploadType.Annotation: {
+            const fileData = file.fileData;
+            if (fileData?.isLabel)
+                return null;
+            // Legacy Nutrient sketches count as photos for filtering, but still
+            // open in the document viewer (they have no Skia canvas state).
+            return fileData?.fileType === 'sketch' ? 'photos' : 'files';
+        }
+        default:
+            return null;
+    }
+}

package/dist/exports.d.ts

@@ -7,7 +7,11 @@ export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
-export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
+export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.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';
+export { desktopBaseUrlForFirebaseProject, desktopFileEditorUrl, type DesktopLinkContext, } from './export/desktopLinks.js';
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
 export * from './calculator/index.js';

package/dist/exports.js

@@ -11,7 +11,13 @@ export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, } from './utils/tolerance.js';
-export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
+export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.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';
+export { classifyFileForExport } from './export/objectKinds.js';
+export { buildJobCsv, escapeCSVField, hyperlinkCell, } from './export/buildJobCsv.js';
+export { desktopBaseUrlForFirebaseProject, desktopFileEditorUrl, } from './export/desktopLinks.js';
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
 // Construction Calculator shared module (schema, units, evaluator, solver,

package/dist/utils/groups.d.ts

@@ -1,4 +1,5 @@
-import type { Group } from '../types/firestore.js';
+import { type Group, type Section } from '../types/firestore.js';
 export declare const DEFAULT_GROUP_INDEX = 0;
 export declare const isDefaultGroup: (group: Pick<Group, "groupIndex"> | null | undefined) => boolean;
 export declare const findDefaultGroup: <T extends Pick<Group, "groupIndex">>(groups: T[] | null | undefined) => T | null;
+export declare const isFormGroupCompleted: (group: Group, section: Section) => boolean;

package/dist/utils/groups.js

@@ -1,3 +1,17 @@
+import { ColumnType } from '../types/firestore.js';
 export const DEFAULT_GROUP_INDEX = 0;
 export const isDefaultGroup = (group) => group?.groupIndex === DEFAULT_GROUP_INDEX;
 export const findDefaultGroup = (groups) => groups?.find((g) => g.groupIndex === DEFAULT_GROUP_INDEX) ?? null;
+// A FORM group (one row of its section's table) counts as complete when every
+// Measurement column holds a value. Angle columns are intentionally excluded
+// (mirrors the apps' header-completion computations), and a section with no
+// Measurement columns is never "complete".
+export const isFormGroupCompleted = (group, section) => {
+    const measurementColumns = section.tableConfig.filter((column) => column.type === ColumnType.Measurement);
+    if (measurementColumns.length === 0)
+        return false;
+    return measurementColumns.every((column) => {
+        const value = group.columns?.[column.id];
+        return value !== undefined && value !== '';
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.7.4",
+  "version": "1.8.0",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",
@@ -25,6 +25,7 @@
     "build": "tsc",
     "prepack": "yarn run build",
     "sync:local": "./scripts/sync-local.sh",
+    "gen:category-icons": "tsc && node ./scripts/gen-category-icons.mjs",
     "test": "vitest",
     "coverage": "vitest run --coverage",
     "format": "prettier --write .",