@ankhorage/rules-design 0.9.0 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,11 @@
1
1
  # Changelog
2
2
 
3
+ ## 0.9.1
4
+
5
+ ### Patch Changes
6
+
7
+ - 3346adc: Recognize semantic HTML landmarks and content alongside evidence-backed layout, card, and transparent-wrapper structures without losing child provenance.
8
+
3
9
  ## 0.9.0
4
10
 
5
11
  ### Minor Changes
package/README.md CHANGED
@@ -3,7 +3,7 @@
3
3
 
4
4
  # @ankhorage/rules-design
5
5
 
6
- ![license: MIT](././paradox/badges/license.svg) ![npm: v0.9.0](././paradox/badges/npm.svg) ![runtime: bun](././paradox/badges/runtime.svg) ![typescript: strict](././paradox/badges/typescript.svg) ![eslint: checked](././paradox/badges/eslint.svg) ![prettier: checked](././paradox/badges/prettier.svg) ![build: checked](././paradox/badges/build.svg) ![tests: checked](././paradox/badges/tests.svg) ![paradox: canonical](././paradox/badges/docs.svg)
6
+ ![license: MIT](././paradox/badges/license.svg) ![npm: v0.9.1](././paradox/badges/npm.svg) ![runtime: bun](././paradox/badges/runtime.svg) ![typescript: strict](././paradox/badges/typescript.svg) ![eslint: checked](././paradox/badges/eslint.svg) ![prettier: checked](././paradox/badges/prettier.svg) ![build: checked](././paradox/badges/build.svg) ![tests: checked](././paradox/badges/tests.svg) ![paradox: canonical](././paradox/badges/docs.svg)
7
7
 
8
8
  Declarative catalog for reusable design rules.
9
9
 
@@ -1,4 +1,5 @@
1
1
  import { recognizeWebsiteStructureProps } from './recognizeWebsiteStructureProps';
2
+ import { websiteStructureEvidence } from './websiteStructureEvidence';
2
3
  import { recognizeWebsiteStructureSemanticComponentType } from './websiteStructureSemantics';
3
4
  import { createWebsiteStructureTreeNode } from './websiteStructureTreeNodes';
4
5
  /*** Recognizes source-linked canonical component trees from validated website observations. */
@@ -52,7 +53,8 @@ function recognizeTreeNode(node, nodesBySourceRef, childNodesByParent, effective
52
53
  return [];
53
54
  }
54
55
  const children = childNodesByParent.get(node.sourceRef) ?? [];
55
- if (!isCyclicSourceRef(node, nodesBySourceRef) && isTransparentWrapper(node, children)) {
56
+ if (!isCyclicSourceRef(node, nodesBySourceRef) &&
57
+ websiteStructureEvidence(node, children).isTransparentWrapper) {
56
58
  return children.flatMap((child) => recognizeTreeNode(child, nodesBySourceRef, childNodesByParent, effectiveParentSourceRef, [...inheritedSourceRefs, node.sourceRef], [...ancestorSourceRefs, node.sourceRef]));
57
59
  }
58
60
  const childRecognitions = children.flatMap((child) => recognizeTreeNode(child, nodesBySourceRef, childNodesByParent, node.sourceRef, [], [...ancestorSourceRefs, node.sourceRef]));
@@ -69,7 +71,7 @@ function createRecognizedTreeNode(node, parent, childNodesByParent, nodesBySourc
69
71
  const props = recognizeWebsiteStructureProps(node);
70
72
  return createWebsiteStructureTreeNode(node, componentType, [...inheritedSourceRefs, node.sourceRef], props, children, cyclic
71
73
  ? 'Source hierarchy contains a cycle.'
72
- : availableObservation(node) === null
74
+ : websiteStructureEvidence(node).availableObservation === null
73
75
  ? 'No available rendered observation exists for this source node.'
74
76
  : 'Visible source node has no canonical component mapping.');
75
77
  }
@@ -89,44 +91,31 @@ function isCyclicSourceRef(node, nodesBySourceRef) {
89
91
  function containsSourceRef(recognitions, sourceRef) {
90
92
  return recognitions.some((recognition) => recognition.nodes.some((node) => node.sourceRefs.includes(sourceRef)));
91
93
  }
92
- /*** Identifies wrappers with no independently meaningful semantic, textual, media, or visual role. */
93
- function isTransparentWrapper(node, children) {
94
- const observation = availableObservation(node);
95
- const tagName = node.dom.tagName.toLowerCase();
96
- return (children.length > 0 &&
97
- node.links.length === 0 &&
98
- node.media.length === 0 &&
99
- node.textRuns.length === 0 &&
100
- (tagName === 'div' || tagName === 'span') &&
101
- observation !== null &&
102
- !hasLayoutRole(observation) &&
103
- !hasSurfaceRole(observation));
104
- }
105
94
  /*** Maps observed DOM semantics and measured layout traits to already representable UI components. */
106
95
  function recognizeComponentType(node, parent, childNodesByParent) {
107
- const observation = availableObservation(node);
96
+ const observation = websiteStructureEvidence(node).availableObservation;
108
97
  if (observation === null)
109
98
  return 'Unknown';
110
99
  const tagName = node.dom.tagName.toLowerCase();
111
100
  const semanticType = recognizeWebsiteStructureSemanticComponentType(tagName);
112
101
  if (semanticType !== null)
113
102
  return semanticType;
114
- if (node.media.length > 0)
115
- return node.media.every((media) => media.kind === 'image') ? 'Image' : 'Media';
116
- if (node.links.length > 0)
117
- return 'Link';
118
- if (node.textRuns.length > 0)
119
- return 'RichText';
120
- if (isGroupedCard(node, parent, childNodesByParent))
121
- return 'Card';
122
103
  const { css } = observation;
123
104
  if (css === null)
124
105
  return 'Unknown';
106
+ if (isGroupedCard(node, parent, childNodesByParent))
107
+ return 'Card';
125
108
  if (css.display.includes('grid'))
126
109
  return 'Grid';
127
110
  if (css.display.includes('flex'))
128
111
  return 'Flex';
129
- return hasLayoutRole(observation) || hasSurfaceRole(observation) ? 'Container' : 'Unknown';
112
+ if (node.media.length > 0)
113
+ return node.media.every((media) => media.kind === 'image') ? 'Image' : 'Media';
114
+ if (node.links.length > 0)
115
+ return 'Link';
116
+ if (node.textRuns.length > 0)
117
+ return 'RichText';
118
+ return websiteStructureEvidence(node).hasVisualRole ? 'Container' : 'Unknown';
130
119
  }
131
120
  /*** Recognizes a card only when a measured sibling group shares explicit surface traits. */
132
121
  function isGroupedCard(node, parent, childNodesByParent) {
@@ -140,70 +129,17 @@ function meaningfulChildren(parentSourceRef, childNodesByParent) {
140
129
  const children = childNodesByParent.get(parentSourceRef) ?? [];
141
130
  return children.flatMap((child) => {
142
131
  const nestedChildren = childNodesByParent.get(child.sourceRef) ?? [];
143
- return isTransparentWrapper(child, nestedChildren)
132
+ return websiteStructureEvidence(child, nestedChildren).isTransparentWrapper
144
133
  ? meaningfulChildren(child.sourceRef, childNodesByParent)
145
134
  : [child];
146
135
  });
147
136
  }
148
137
  /*** Tests whether a parent has measured Grid or Flex grouping semantics. */
149
138
  function isLayoutGroup(node) {
150
- const css = availableObservation(node)?.css;
139
+ const css = websiteStructureEvidence(node).availableObservation?.css;
151
140
  return css === null || css === undefined ? false : /grid|flex/.test(css.display);
152
141
  }
153
142
  /*** Requires padding plus radius, border, or shadow so colored columns are not invented as cards. */
154
143
  function isCardSurface(node) {
155
- const observation = availableObservation(node);
156
- const css = observation?.css;
157
- return (css !== null &&
158
- css !== undefined &&
159
- hasNonZeroEdge(css.padding) &&
160
- (hasNonZeroCssValue(css.borderRadius) ||
161
- hasNonZeroCssValue(css.borderWidth) ||
162
- css.boxShadow !== 'none'));
163
- }
164
- /*** Selects a visible available observation deterministically without inventing a missing style. */
165
- function availableObservation(node) {
166
- return ([...node.observations]
167
- .sort((left, right) => left.viewportId.localeCompare(right.viewportId) ||
168
- left.stateId.localeCompare(right.stateId))
169
- .find((observation) => observation.availability.status === 'available' &&
170
- observation.css !== null &&
171
- observation.rect !== null &&
172
- observation.rect.width > 0 &&
173
- observation.rect.height > 0 &&
174
- observation.css.display !== 'none' &&
175
- observation.css.visibility !== 'hidden' &&
176
- observation.css.visibility !== 'collapse' &&
177
- observation.css.opacity !== '0') ?? null);
178
- }
179
- /*** Identifies layout evidence that gives an otherwise generic container a real component role. */
180
- function hasLayoutRole(observation) {
181
- const { css } = observation;
182
- return (css !== null &&
183
- (css.display.includes('grid') ||
184
- css.display.includes('flex') ||
185
- hasNonZeroEdge(css.padding) ||
186
- hasNonZeroEdge(css.margin) ||
187
- hasNonZeroCssValue(css.gap)));
188
- }
189
- /*** Identifies measured border, radius, background, or shadow evidence for a visual container. */
190
- function hasSurfaceRole(observation) {
191
- const { css } = observation;
192
- return (css !== null &&
193
- (hasNonZeroCssValue(css.borderRadius) ||
194
- hasNonZeroCssValue(css.borderWidth) ||
195
- css.boxShadow !== 'none' ||
196
- !isTransparentColor(css.backgroundColor)));
197
- }
198
- /*** Tests CSS box edges without parsing or normalizing their original literals. */
199
- function hasNonZeroEdge(edges) {
200
- return [edges.top, edges.right, edges.bottom, edges.left].some(hasNonZeroCssValue);
201
- }
202
- /*** Detects non-zero CSS literals while preserving their exact source value elsewhere. */
203
- function hasNonZeroCssValue(value) {
204
- return value !== '0' && value !== '0px' && value !== 'normal' && value !== 'auto';
205
- }
206
- /*** Recognizes the transparent computed color forms without assigning a color token. */
207
- function isTransparentColor(value) {
208
- return value === 'transparent' || value === 'rgba(0, 0, 0, 0)';
144
+ return websiteStructureEvidence(node).hasCardSurface;
209
145
  }
@@ -0,0 +1,10 @@
1
+ import type { WebsiteNodeObservation, WebsiteObservedNode } from '@ankhorage/contracts/website';
2
+ /*** Collects complete evidence needed to classify an observed website structure node. */
3
+ export declare function websiteStructureEvidence(node: WebsiteObservedNode, children?: readonly WebsiteObservedNode[]): WebsiteStructureEvidence;
4
+ interface WebsiteStructureEvidence {
5
+ readonly availableObservation: WebsiteNodeObservation | null;
6
+ readonly hasCardSurface: boolean;
7
+ readonly hasVisualRole: boolean;
8
+ readonly isTransparentWrapper: boolean;
9
+ }
10
+ export {};
@@ -0,0 +1,88 @@
1
+ /*** Collects complete evidence needed to classify an observed website structure node. */
2
+ export function websiteStructureEvidence(node, children = []) {
3
+ return {
4
+ availableObservation: availableObservation(node),
5
+ hasCardSurface: hasCardSurface(node),
6
+ hasVisualRole: hasVisualRole(node),
7
+ isTransparentWrapper: isTransparentWrapper(node, children),
8
+ };
9
+ }
10
+ /*** Selects a visible available observation deterministically without inventing a missing style. */
11
+ function availableObservation(node) {
12
+ return ([...node.observations]
13
+ .sort((left, right) => left.viewportId.localeCompare(right.viewportId) ||
14
+ left.stateId.localeCompare(right.stateId))
15
+ .find((observation) => observation.availability.status === 'available' &&
16
+ observation.css !== null &&
17
+ observation.rect !== null &&
18
+ observation.rect.width > 0 &&
19
+ observation.rect.height > 0 &&
20
+ observation.css.display !== 'none' &&
21
+ observation.css.visibility !== 'hidden' &&
22
+ observation.css.visibility !== 'collapse' &&
23
+ observation.css.opacity !== '0') ?? null);
24
+ }
25
+ /*** Requires padding plus radius, border, or shadow so colored columns are not invented as cards. */
26
+ function hasCardSurface(node) {
27
+ const css = availableObservation(node)?.css;
28
+ return (css !== null &&
29
+ css !== undefined &&
30
+ hasNonZeroEdge(css.padding) &&
31
+ (hasNonZeroCssValue(css.borderRadius) ||
32
+ hasNonZeroCssValue(css.borderWidth) ||
33
+ css.boxShadow !== 'none'));
34
+ }
35
+ /*** Tests whether a visible observation gives a generic node a layout or surface role. */
36
+ function hasVisualRole(node) {
37
+ const observation = availableObservation(node);
38
+ return observation !== null && (hasLayoutRole(observation) || hasSurfaceRole(observation));
39
+ }
40
+ /*** Identifies wrappers only when complete observations prove no independent role. */
41
+ function isTransparentWrapper(node, children) {
42
+ const tagName = node.dom.tagName.toLowerCase();
43
+ return (children.length > 0 &&
44
+ node.links.length === 0 &&
45
+ node.media.length === 0 &&
46
+ node.textRuns.length === 0 &&
47
+ (tagName === 'div' || tagName === 'span') &&
48
+ node.observations.length > 0 &&
49
+ node.observations.every(isTransparentObservation));
50
+ }
51
+ /*** Requires usable CSS evidence and excludes every measured layout or surface role. */
52
+ function isTransparentObservation(observation) {
53
+ return (observation.availability.status === 'available' &&
54
+ observation.css !== null &&
55
+ !hasLayoutRole(observation) &&
56
+ !hasSurfaceRole(observation));
57
+ }
58
+ /*** Identifies layout evidence that gives an otherwise generic container a real component role. */
59
+ function hasLayoutRole(observation) {
60
+ const { css } = observation;
61
+ return (css !== null &&
62
+ (css.display.includes('grid') ||
63
+ css.display.includes('flex') ||
64
+ hasNonZeroEdge(css.padding) ||
65
+ hasNonZeroEdge(css.margin) ||
66
+ hasNonZeroCssValue(css.gap)));
67
+ }
68
+ /*** Identifies measured border, radius, background, or shadow evidence for a visual container. */
69
+ function hasSurfaceRole(observation) {
70
+ const { css } = observation;
71
+ return (css !== null &&
72
+ (hasNonZeroCssValue(css.borderRadius) ||
73
+ hasNonZeroCssValue(css.borderWidth) ||
74
+ css.boxShadow !== 'none' ||
75
+ !isTransparentColor(css.backgroundColor)));
76
+ }
77
+ /*** Tests CSS box edges without parsing or normalizing their original literals. */
78
+ function hasNonZeroEdge(edges) {
79
+ return [edges.top, edges.right, edges.bottom, edges.left].some(hasNonZeroCssValue);
80
+ }
81
+ /*** Detects non-zero CSS literals while preserving their exact source value elsewhere. */
82
+ function hasNonZeroCssValue(value) {
83
+ return value !== '0' && value !== '0px' && value !== 'normal' && value !== 'auto';
84
+ }
85
+ /*** Recognizes transparent computed-color forms without assigning a color token. */
86
+ function isTransparentColor(value) {
87
+ return value === 'transparent' || value === 'rgba(0, 0, 0, 0)';
88
+ }
@@ -6,22 +6,36 @@ export function recognizeWebsiteStructureSemanticComponentType(tagName) {
6
6
  }
7
7
  const semanticComponentTypes = [
8
8
  ['a', 'Link'],
9
+ ['address', 'RichText'],
10
+ ['aside', 'Container'],
9
11
  ['article', 'Container'],
10
12
  ['audio', 'Media'],
11
13
  ['body', 'Container'],
12
14
  ['blockquote', 'RichText'],
13
15
  ['button', 'Button'],
16
+ ['dd', 'ListItem'],
17
+ ['details', 'Container'],
18
+ ['dl', 'List'],
19
+ ['dt', 'ListItem'],
20
+ ['em', 'RichText'],
14
21
  ['footer', 'Footer'],
15
22
  ['form', 'Form'],
23
+ ['figure', 'Container'],
24
+ ['figcaption', 'RichText'],
16
25
  ['header', 'Header'],
17
26
  ['iframe', 'Media'],
18
27
  ['img', 'Image'],
19
28
  ['label', 'RichText'],
20
29
  ['li', 'ListItem'],
21
30
  ['main', 'Container'],
31
+ ['menu', 'List'],
32
+ ['nav', 'Container'],
22
33
  ['ol', 'List'],
23
34
  ['p', 'RichText'],
24
35
  ['section', 'Section'],
36
+ ['small', 'RichText'],
37
+ ['strong', 'RichText'],
38
+ ['summary', 'RichText'],
25
39
  ['ul', 'List'],
26
40
  ['video', 'Media'],
27
41
  ];
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ankhorage/rules-design",
3
- "version": "0.9.0",
3
+ "version": "0.9.1",
4
4
  "description": "Declarative catalog for reusable design rules.",
5
5
  "license": "MIT",
6
6
  "homepage": "https://github.com/ankhorage/rules-design#readme",