@reekon-tools/boldr-utils 1.7.5 → 1.8.1

package/dist/annotation/canvas/elements/BackgroundImageElement.js

@@ -42,6 +42,11 @@ const useBackgroundUrl = (image, resolveUrl) => {
 // on a null/undefined source (despite its DataSourceParam type), so it can't
 // be called unconditionally from a component that usually renders raster
 // backgrounds. An empty url resolves to null (nothing to draw yet).
+// Loaded through Skia's own scheme-agnostic data loader rather than fetch():
+// RN's Android networking rejects non-http(s) schemes, and offline-first
+// consumers resolve the background to a local file:// URI (fromURI handles
+// file://, http(s) and data: on native and web alike). fetch() remains as a
+// fallback for any environment where fromURI can't service the URL.
 const useBackgroundSvg = (url) => {
     const [svg, setSvg] = useState(null);
     useEffect(() => {
@@ -52,9 +57,16 @@ const useBackgroundSvg = (url) => {
         let cancelled = false;
         (async () => {
             try {
-                const res = await fetch(url);
-                const text = await res.text();
-                const next = Skia.SVG.MakeFromString(text);
+                let next = null;
+                try {
+                    const data = await Skia.Data.fromURI(url);
+                    next = Skia.SVG.MakeFromData(data);
+                    data.dispose();
+                }
+                catch {
+                    const res = await fetch(url);
+                    next = Skia.SVG.MakeFromString(await res.text());
+                }
                 if (!cancelled)
                     setSvg(next);
             }

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.js

@@ -97,8 +97,9 @@ export function buildJobCsv(input) {
             const columnHeaders = [];
             section.tableConfig.forEach((column) => {
                 columnHeaders.push(column.name);
-                if (column.type === ColumnType.Measurement ||
-                    column.type === ColumnType.Angle) {
+                if (includeField('notes') &&
+                    (column.type === ColumnType.Measurement ||
+                        column.type === ColumnType.Angle)) {
                     columnHeaders.push(`${column.name} Notes`);
                 }
             });
@@ -164,8 +165,9 @@ export function buildJobCsv(input) {
                     else {
                         row.push('');
                     }
-                    if (column.type === ColumnType.Measurement ||
-                        column.type === ColumnType.Angle) {
+                    if (includeField('notes') &&
+                        (column.type === ColumnType.Measurement ||
+                            column.type === ColumnType.Angle)) {
                         if (group.descriptions && group.descriptions[column.id]) {
                             row.push(escapeCSVField(group.descriptions[column.id]));
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.7.5",
+  "version": "1.8.1",
   "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 .",