@ankhorage/studio 2.0.22 → 2.0.24

package/dist/manifestState.js

@@ -44,12 +44,20 @@ export const DEFAULT_STUDIO_SCREEN_TEMPLATE = {
         },
     ],
 };
+/***
+ * Generate a Studio manifest-state identifier from the current time, randomness, and optional prefix.
+ * @todo Move this identifier policy from the src root into the manifest domain or the domain that owns generated authoring IDs.
+ */
 export const generateManifestStateId = (prefix) => {
     const timestamp = Date.now().toString(36);
     const random = Math.random().toString(36).substring(2, 11);
     const id = `${timestamp}-${random}`;
     return prefix ? `${prefix.toLowerCase()}-${id}` : id;
 };
+/***
+ * Serialize the manifest fields used to detect broad Studio authoring-state changes.
+ * @todo Move this manifest state projection from the src root into the manifest domain.
+ */
 export function createStudioManifestFingerprint(manifest) {
     if (!manifest)
         return '';
@@ -65,12 +73,24 @@ export function createStudioManifestFingerprint(manifest) {
         infra: manifest.infra,
     });
 }
+/***
+ * Convert a navigator parent path to the stable key used for route grouping.
+ * @todo Move this route-path helper from the src root into routes/.
+ */
 export function pathToKey(path) {
     return path.length === 0 ? '__root__' : path.join('/');
 }
+/***
+ * Return whether a route segment represents an Expo Router-style group segment.
+ * @todo Move this route semantic helper from the src root into routes/.
+ */
 export function isRouteGroupSegment(segment) {
     return /^\(.*\)$/.test(segment);
 }
+/***
+ * Recursively collect screen-targeting routes together with their navigator and route paths.
+ * @todo Move route traversal from the src root into routes/.
+ */
 export function collectScreenRouteEntries(routes, parentPath = [], routePathPrefix = []) {
     const entries = [];
     for (const route of routes) {
@@ -89,6 +109,10 @@ export function collectScreenRouteEntries(routes, parentPath = [], routePathPref
     }
     return entries;
 }
+/***
+ * Group collected screen routes by the navigator parent path that owns them.
+ * @todo Move route grouping from the src root into routes/.
+ */
 export function groupScreenRouteEntries(entries) {
     const groups = new Map();
     for (const entry of entries) {
@@ -104,9 +128,9 @@ export function groupScreenRouteEntries(entries) {
     }
     return Array.from(groups.values());
 }
-/**
- * Verifies the Studio manifest invariant that route registry keys and stable
- * ScreenSpec identities are the same unique value.
+/***
+ * Verify that every screen registry key equals its unique stable ScreenSpec identifier.
+ * @todo Move this manifest screen invariant from the src root into the manifest domain.
  */
 export function hasCanonicalStudioScreenRegistryIdentity(screens) {
     const screenIds = new Set();
@@ -117,14 +141,18 @@ export function hasCanonicalStudioScreenRegistryIdentity(screens) {
     }
     return true;
 }
+/***
+ * Resolve a screen by stable identifier only when the manifest screen registry satisfies its canonical identity invariant.
+ * @todo Move this screen lookup from the src root into the manifest domain.
+ */
 function resolveCanonicalStudioScreen(manifest, screenId) {
     if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens))
         return undefined;
     return Object.values(manifest.screens).find((screen) => screen.id === screenId);
 }
-/**
- * Derives the complete package-neutral screen/navigation authoring model from
- * the manifest without flattening its navigator tree.
+/***
+ * Derive the complete screen/navigation authoring model and diagnostics without flattening the navigator tree.
+ * @todo Move navigation-model derivation from the src root into routes/.
  */
 export function deriveStudioScreenNavigationModel(manifest) {
     const primaryNavigatorPath = getPrimaryNavigatorPath(manifest.navigator.routes);
@@ -183,9 +211,9 @@ export function deriveStudioScreenNavigationModel(manifest) {
         diagnostics,
     };
 }
-/**
- * Returns a concrete canonical app pathname only when a screen has one route
- * reference and that route does not require runtime parameters.
+/***
+ * Resolve a concrete app pathname only when a screen has one unique, non-dynamic route reference.
+ * @todo Move canonical route-path resolution from the src root into routes/.
  */
 export function resolveStudioScreenAppPath(model, screenId) {
     const matchingEntries = model.screens.filter((candidate) => candidate.screenId === screenId);
@@ -207,6 +235,10 @@ export function resolveStudioScreenAppPath(model, screenId) {
     const matchingReferences = model.screens.flatMap((candidate) => candidate.routeReferences.filter((candidateReference) => candidateReference.pathnamePattern === reference.pathnamePattern));
     return matchingReferences.length === 1 ? reference.pathnamePattern : null;
 }
+/***
+ * Traverse a navigator tree to collect route references and navigation diagnostics for each screen.
+ * @todo Move navigation traversal and diagnostics from the src root into routes/.
+ */
 function collectNavigationModelReferences(args) {
     const { navigator, screens, primaryNavigatorPath, parentPath, routePathPrefix, runtimePathPrefix, diagnostics, referencesByRegistryKey, } = args;
     const siblingNameCounts = new Map();
@@ -301,25 +333,40 @@ function collectNavigationModelReferences(args) {
         }
     }
 }
+/***
+ * Append one route's explicit or named path segments to the current runtime route path.
+ * @todo Move runtime route-path construction from the src root into routes/.
+ */
 function appendRuntimeRoutePath(runtimePathPrefix, route) {
     const explicitPath = route.path?.trim();
     const segmentPath = explicitPath ?? route.name;
     const segments = segmentPath.split('/').filter(Boolean);
     return explicitPath?.startsWith('/') ? segments : [...runtimePathPrefix, ...segments];
 }
+/***
+ * Compare two route paths for ordered segment equality.
+ * @todo Keep this small comparison helper local to routes/ unless broader reuse is demonstrated.
+ */
 function pathsEqual(first, second) {
     return (first.length === second.length && first.every((value, index) => value === second.at(index)));
 }
+/***
+ * Format a route parent path for navigation diagnostic messages.
+ * @todo Move route diagnostic formatting from the src root into routes/.
+ */
 function formatParentPath(parentPath) {
     return parentPath.length === 0 ? '<root>' : parentPath.join('/');
 }
+/***
+ * List routed screen identifiers in navigator traversal order.
+ * @todo Move route ordering behavior from the src root into routes/.
+ */
 export function listScreenIdsInRouteOrder(routes) {
     return collectScreenRouteEntries(routes).map((entry) => entry.screenId);
 }
-/**
- * Resolves the initial leaf screen selected by a nested navigator tree.
- * Each navigator's initial route is preferred, with unusable routes falling
- * back to the first route that reaches an available screen.
+/***
+ * Resolve the initial leaf screen selected by a nested navigator tree, falling back to the first usable route.
+ * @todo Move initial-route resolution from the src root into routes/.
  */
 export function resolveInitialScreenId(navigator, screens) {
     if (screens && !hasCanonicalStudioScreenRegistryIdentity(screens))
@@ -342,6 +389,10 @@ export function resolveInitialScreenId(navigator, screens) {
     }
     return null;
 }
+/***
+ * Resolve the active screen Studio should select when a manifest is first opened.
+ * @todo Move initial Studio screen selection out of the src root into routes/ or selection/ according to its caller boundary.
+ */
 export function resolveInitialActiveScreenId(manifest) {
     if (!manifest || !hasCanonicalStudioScreenRegistryIdentity(manifest.screens))
         return null;
@@ -349,11 +400,19 @@ export function resolveInitialActiveScreenId(manifest) {
     const [firstScreenId] = Object.values(manifest.screens).map((screen) => screen.id);
     return firstRoutedScreenId ?? firstScreenId ?? null;
 }
+/***
+ * Resolve the root UI node for the active canonical screen.
+ * @todo Move active-screen root resolution from the src root into the manifest/selection boundary.
+ */
 export function resolveActiveRootNode(manifest, activeScreenId) {
     if (!manifest || !activeScreenId)
         return null;
     return resolveCanonicalStudioScreen(manifest, activeScreenId)?.root ?? null;
 }
+/***
+ * Recursively find a UI node by identifier in a manifest-owned UI tree.
+ * @todo Move UI-tree traversal from the src root into canvas/.
+ */
 export function findNodeInManifest(root, id) {
     if (root.id === id)
         return root;
@@ -364,11 +423,19 @@ export function findNodeInManifest(root, id) {
     }
     return null;
 }
+/***
+ * Keep a selected node identifier only while that node still exists in the active tree.
+ * @todo Move selection validity policy from the src root into selection/.
+ */
 export function resolveSafeSelectedNodeId(rootNode, selectedNodeId) {
     if (!selectedNodeId || !rootNode)
         return null;
     return findNodeInManifest(rootNode, selectedNodeId) ? selectedNodeId : null;
 }
+/***
+ * Find the canonical screen whose UI tree contains a given node identifier.
+ * @todo Move screen ownership lookup from the src root into the manifest/canvas boundary.
+ */
 export function findScreenIdForNode(manifest, nodeId) {
     if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens))
         return null;
@@ -379,6 +446,10 @@ export function findScreenIdForNode(manifest, nodeId) {
     }
     return null;
 }
+/***
+ * Update authored properties of one node in the active screen while preserving manifest immutability.
+ * @todo Move canvas node mutation from the src root into canvas/.
+ */
 export function updateStudioManifestNode(manifest, activeScreenId, nodeId, newProps) {
     if (!activeScreenId)
         return manifest;
@@ -399,6 +470,10 @@ export function updateStudioManifestNode(manifest, activeScreenId, nodeId, newPr
         },
     };
 }
+/***
+ * Delete a non-root node from the active screen and remove data bindings owned by the deleted subtree.
+ * @todo Split this canvas mutation and binding cleanup between canvas/ and bindings/ instead of the src root.
+ */
 export function deleteStudioManifestNode(manifest, activeScreenId, nodeId) {
     if (!activeScreenId)
         return manifest;
@@ -425,6 +500,10 @@ export function deleteStudioManifestNode(manifest, activeScreenId, nodeId) {
         },
     };
 }
+/***
+ * Insert a new UI node at a validated canvas placement in the active screen.
+ * @todo Move canvas insertion orchestration from the src root into canvas/.
+ */
 export function insertStudioManifestNodeAtPlacement(args) {
     const { manifest, activeScreenId, placement, newNode, componentMeta } = args;
     if (!activeScreenId)
@@ -454,6 +533,10 @@ export function insertStudioManifestNodeAtPlacement(args) {
         insertedNodeId: newNode.id,
     };
 }
+/***
+ * Move an existing UI node to a validated canvas placement in the active screen.
+ * @todo Move canvas movement orchestration from the src root into canvas/.
+ */
 export function moveStudioManifestNodeToPlacement(args) {
     const { manifest, activeScreenId, nodeId, placement, componentMeta } = args;
     if (!activeScreenId)
@@ -483,12 +566,24 @@ export function moveStudioManifestNodeToPlacement(args) {
         movedNodeId: movement.movedNodeId,
     };
 }
+/***
+ * Replace the manifest component data-binding registry.
+ * @todo Move binding-state mutation from the src root into bindings/.
+ */
 export function updateStudioManifestDataBindings(manifest, dataBindings) {
     return { ...manifest, dataBindings };
 }
+/***
+ * Replace the manifest data-source registry.
+ * @todo Resolve data-source authoring ownership with bindings/external APIs and remove this src-root mutation.
+ */
 export function updateStudioManifestDataSources(manifest, dataSources) {
     return { ...manifest, dataSources };
 }
+/***
+ * Create the default light/dark theme configuration for a newly authored theme.
+ * @todo Extract theme authoring from manifestState.ts; the current Studio structure target does not yet name a dedicated theme domain.
+ */
 export function createDefaultThemeConfig(themeIndex, id = generateManifestStateId('theme')) {
     return {
         id,
@@ -503,9 +598,17 @@ export function createDefaultThemeConfig(themeIndex, id = generateManifestStateI
         },
     };
 }
+/***
+ * Append a theme to the manifest, creating a default theme when none is supplied.
+ * @todo Extract theme authoring from manifestState.ts into its resolved owner.
+ */
 export function addStudioManifestTheme(manifest, theme = createDefaultThemeConfig(manifest.themes.length)) {
     return { ...manifest, themes: [...manifest.themes, theme] };
 }
+/***
+ * Merge shared and mode-specific updates into one manifest theme.
+ * @todo Extract theme authoring from manifestState.ts into its resolved owner.
+ */
 export function updateStudioManifestTheme(manifest, themeId, updates) {
     return {
         ...manifest,
@@ -522,6 +625,10 @@ export function updateStudioManifestTheme(manifest, themeId, updates) {
         }),
     };
 }
+/***
+ * Delete a theme while preserving at least one theme and a valid active-theme identifier.
+ * @todo Extract theme authoring from manifestState.ts into its resolved owner.
+ */
 export function deleteStudioManifestTheme(manifest, themeId) {
     if (manifest.themes.length <= 1)
         return manifest;
@@ -531,12 +638,24 @@ export function deleteStudioManifestTheme(manifest, themeId) {
         : manifest.activeThemeId;
     return { ...manifest, themes, activeThemeId };
 }
+/***
+ * Set the active theme identifier in the manifest.
+ * @todo Extract theme authoring from manifestState.ts into its resolved owner.
+ */
 export function setStudioManifestActiveThemeId(manifest, activeThemeId) {
     return { ...manifest, activeThemeId };
 }
+/***
+ * Set the active light/dark theme mode in the manifest.
+ * @todo Extract theme authoring from manifestState.ts into its resolved owner.
+ */
 export function setStudioManifestActiveThemeMode(manifest, activeThemeMode) {
     return { ...manifest, activeThemeMode };
 }
+/***
+ * Replace OAuth providers while preserving or creating the surrounding manifest auth configuration.
+ * @todo Move auth policy from the src root into auth/.
+ */
 export function updateStudioManifestOAuthProviders(manifest, providers) {
     const previousAuth = manifest.infra.auth ?? {
         provider: 'supabase',
@@ -563,6 +682,10 @@ export function updateStudioManifestOAuthProviders(manifest, providers) {
         },
     };
 }
+/***
+ * Resolve the navigator path Studio treats as the primary application navigator.
+ * @todo Move primary-navigator policy from the src root into routes/.
+ */
 export function getPrimaryNavigatorPath(routes) {
     const appGroupRoute = routes.find((route) => route.name === '(app)' && route.navigator?.routes);
     if (appGroupRoute)
@@ -572,6 +695,10 @@ export function getPrimaryNavigatorPath(routes) {
         return ['app'];
     return [];
 }
+/***
+ * Find the navigator parent path that owns a route targeting the requested screen.
+ * @todo Move route traversal from the src root into routes/.
+ */
 export function findParentPathForScreenId(routes, screenId, parentPath = [], routePathPrefix = []) {
     for (const route of routes) {
         const routePath = [...routePathPrefix, route.name];
@@ -585,6 +712,10 @@ export function findParentPathForScreenId(routes, screenId, parentPath = [], rou
     }
     return null;
 }
+/***
+ * Resolve the direct route collection owned by a navigator parent path.
+ * @todo Move navigator path lookup from the src root into routes/.
+ */
 export function findRoutesAtParentPath(routes, parentPath) {
     if (parentPath.length === 0)
         return routes;
@@ -599,6 +730,10 @@ export function findRoutesAtParentPath(routes, parentPath) {
         return null;
     return findRoutesAtParentPath(route.navigator.routes, rest);
 }
+/***
+ * Insert a route into the navigator identified by a parent path without mutating the existing tree.
+ * @todo Move route-tree mutation from the src root into routes/.
+ */
 export function insertRouteAtParentPath(routes, parentPath, newRoute) {
     if (parentPath.length === 0)
         return [...routes, newRoute];
@@ -619,6 +754,10 @@ export function insertRouteAtParentPath(routes, parentPath, newRoute) {
         };
     });
 }
+/***
+ * Resolve a nested navigator by its route-name path.
+ * @todo Move navigator lookup from the src root into routes/.
+ */
 export function findNavigatorAtPath(navigator, parentPath) {
     if (parentPath.length === 0)
         return navigator;
@@ -633,6 +772,10 @@ export function findNavigatorAtPath(navigator, parentPath) {
         return null;
     return findNavigatorAtPath(route.navigator, rest);
 }
+/***
+ * Immutably update the navigator identified by a route-name path.
+ * @todo Move navigator-tree mutation from the src root into routes/.
+ */
 export function updateNavigatorAtPath(navigator, parentPath, updater) {
     if (parentPath.length === 0)
         return updater(navigator);
@@ -653,6 +796,10 @@ export function updateNavigatorAtPath(navigator, parentPath, updater) {
         }),
     };
 }
+/***
+ * Change the primary navigator type when the requested navigator type is valid and different.
+ * @todo Move navigator authoring policy from the src root into routes/.
+ */
 export function setStudioManifestNavigatorType(manifest, type) {
     if (!NAVIGATOR_TYPES.includes(type))
         return manifest;
@@ -668,6 +815,10 @@ export function setStudioManifestNavigatorType(manifest, type) {
         })),
     };
 }
+/***
+ * Change the primary navigator initial route when the requested sibling route is unique.
+ * @todo Move navigator authoring policy from the src root into routes/.
+ */
 export function setStudioManifestNavigatorInitialRoute(manifest, routeName) {
     const normalizedRoute = routeName.trim();
     if (!normalizedRoute)
@@ -689,6 +840,10 @@ export function setStudioManifestNavigatorInitialRoute(manifest, routeName) {
         })),
     };
 }
+/***
+ * Set whether one route is visible in primary navigation while preserving the canonical visible representation.
+ * @todo Move route visibility authoring from the src root into routes/.
+ */
 export function setStudioManifestRoutePrimaryNavigationVisibility(args) {
     const { manifest, parentPath, routeName, showInPrimaryNavigation } = args;
     const navigator = findNavigatorAtPath(manifest.navigator, parentPath);
@@ -721,6 +876,10 @@ export function setStudioManifestRoutePrimaryNavigationVisibility(args) {
         })),
     };
 }
+/***
+ * Reorder one uniquely named route within its navigator parent.
+ * @todo Move route ordering authoring from the src root into routes/.
+ */
 export function moveStudioManifestRoute(args) {
     const { manifest, parentPath, routeName, toIndex } = args;
     if (!Number.isInteger(toIndex))
@@ -746,6 +905,10 @@ export function moveStudioManifestRoute(args) {
         }),
     };
 }
+/***
+ * Create a new screen from a template, generate a collision-free route, and make the new screen active.
+ * @todo Split screen creation between manifest screen state and routes/ instead of keeping both in one src-root function.
+ */
 export function addStudioManifestScreen(args) {
     const { manifest, activeScreenId, createId = generateManifestStateId } = args;
     if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens)) {
@@ -791,6 +954,10 @@ export function addStudioManifestScreen(args) {
         },
     };
 }
+/***
+ * Delete a screen, remove route references and bindings for its subtree, and resolve a safe next active screen.
+ * @todo Split this cross-domain operation across manifest, routes/, bindings/, and selection application responsibilities.
+ */
 export function deleteStudioManifestScreen(manifest, screenId, activeScreenId) {
     if (!hasCanonicalStudioScreenRegistryIdentity(manifest.screens)) {
         return { manifest, activeScreenId };
@@ -824,6 +991,10 @@ export function deleteStudioManifestScreen(manifest, screenId, activeScreenId) {
         },
     };
 }
+/***
+ * Recursively remove a screen target from routes and prune nested navigators that become empty.
+ * @todo Move route cleanup from the src root into routes/.
+ */
 export function removeScreenIdFromRoutes(routes, screenId) {
     const nextRoutes = [];
     for (const route of routes) {
@@ -849,6 +1020,10 @@ export function removeScreenIdFromRoutes(routes, screenId) {
     }
     return nextRoutes;
 }
+/***
+ * Generate a route name that is unique among sibling routes by appending a numeric suffix when needed.
+ * @todo Move route-name generation from the src root into routes/.
+ */
 export function makeUniqueSiblingRouteName(base, siblingRoutes) {
     const normalized = normalizeRouteName(base);
     const existingNames = new Set(siblingRoutes.map((route) => route.name));
@@ -860,6 +1035,10 @@ export function makeUniqueSiblingRouteName(base, siblingRoutes) {
     }
     return `${normalized}-${suffix}`;
 }
+/***
+ * Convert route path segments to the canonical pathname pattern used by Studio authoring.
+ * @todo Move canonical route-pattern logic from the src root into routes/.
+ */
 export function toCanonicalRoutePattern(routePath) {
     const normalized = routePath.filter((segment) => !isRouteGroupSegment(segment));
     while (normalized[0] === 'index')
@@ -868,6 +1047,10 @@ export function toCanonicalRoutePattern(routePath) {
         normalized.pop();
     return normalized.length ? `/${normalized.join('/')}` : '/';
 }
+/***
+ * Generate a route name that avoids both sibling-name and canonical-path collisions.
+ * @todo Move route-name collision policy from the src root into routes/.
+ */
 export function makeUniqueRouteNameForParent(baseRouteName, siblingRoutes, parentPath, existingPatterns) {
     const siblingNames = new Set(siblingRoutes.map((route) => route.name));
     let candidate = baseRouteName;
@@ -879,6 +1062,10 @@ export function makeUniqueRouteNameForParent(baseRouteName, siblingRoutes, paren
     }
     return candidate;
 }
+/***
+ * Normalize arbitrary screen text into the lowercase hyphenated route-name form used by Studio.
+ * @todo Keep this semantic route-name normalization under routes/ rather than extracting it as a generic slug utility.
+ */
 function normalizeRouteName(value) {
     return (value
         .trim()
@@ -886,6 +1073,10 @@ function normalizeRouteName(value) {
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '') || 'screen');
 }
+/***
+ * Collect canonical pathname patterns for every route in a nested navigator tree.
+ * @todo Move route-pattern traversal from the src root into routes/.
+ */
 function collectCanonicalRoutePatterns(routes, runtimePathPrefix = []) {
     const patterns = [];
     for (const route of routes) {
@@ -897,6 +1088,10 @@ function collectCanonicalRoutePatterns(routes, runtimePathPrefix = []) {
     }
     return patterns;
 }
+/***
+ * Deep-clone a UI node tree while assigning fresh identifiers and copying mutable node data.
+ * @todo Move UI-tree cloning from the src root into canvas/.
+ */
 function cloneNodeWithNewIds(node, createId) {
     const clonedNode = {
         ...node,
@@ -908,6 +1103,10 @@ function cloneNodeWithNewIds(node, createId) {
     }
     return clonedNode;
 }
+/***
+ * Immutably update alias, style, and props for a node in a UI tree.
+ * @todo Move UI-tree mutation from the src root into canvas/ or properties/ according to final authoring ownership.
+ */
 function updateNodeInManifestTree(root, id, newProps) {
     if (root.id === id) {
         const { alias, style, ...rest } = newProps;
@@ -926,6 +1125,10 @@ function updateNodeInManifestTree(root, id, newProps) {
     const hasChanged = nextChildren.some((child, index) => child !== root.children?.at(index));
     return hasChanged ? { ...root, children: nextChildren } : root;
 }
+/***
+ * Immutably remove a node from a UI tree while preserving the remaining hierarchy.
+ * @todo Move UI-tree mutation from the src root into canvas/.
+ */
 function removeNodeFromManifestTree(root, nodeId) {
     if (root.id === nodeId)
         return null;
@@ -939,6 +1142,10 @@ function removeNodeFromManifestTree(root, nodeId) {
     const hasChanged = nextChildren.some((child, index) => child !== root.children?.at(index));
     return hasChanged ? { ...root, children: nextChildren } : root;
 }
+/***
+ * Collect every node identifier in a UI subtree.
+ * @todo Move UI-tree traversal from the src root into canvas/.
+ */
 function collectNodeIds(root) {
     const ids = new Set();
     const visit = (node) => {
@@ -949,6 +1156,10 @@ function collectNodeIds(root) {
     visit(root);
     return ids;
 }
+/***
+ * Repair a navigator's initial-route field after route removal while preserving canonical omission when no initial route exists.
+ * @todo Move navigator normalization from the src root into routes/.
+ */
 function normalizeNavigatorAfterRouteUpdate(navigator) {
     const nextRoutes = navigator.routes;
     let nextInitialRouteName = navigator.initialRouteName;
@@ -965,6 +1176,10 @@ function normalizeNavigatorAfterRouteUpdate(navigator) {
     }
     return { ...navigator, routes: nextRoutes, initialRouteName: nextInitialRouteName };
 }
+/***
+ * Narrow an unknown node style value to the string-or-number style record accepted by Studio node updates.
+ * @todo Keep this semantic style predicate with the canvas/properties authoring logic rather than treating it as a generic record utility.
+ */
 function isStyleRecord(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;