@ankhorage/rules-design 0.6.0 → 0.7.0
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 +6 -0
- package/README.md +1 -1
- package/dist/features/website-recognition/recognizeWebsiteStructure.d.ts +9 -0
- package/dist/features/website-recognition/recognizeWebsiteStructure.js +209 -0
- package/dist/features/website-recognition/recognizeWebsiteStructureProps.d.ts +3 -0
- package/dist/features/website-recognition/recognizeWebsiteStructureProps.js +36 -0
- package/dist/features/website-recognition/websiteStructureSemantics.d.ts +2 -0
- package/dist/features/website-recognition/websiteStructureSemantics.js +27 -0
- package/dist/features/website-recognition/websiteStructureTreeNodes.d.ts +4 -0
- package/dist/features/website-recognition/websiteStructureTreeNodes.js +39 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
package/README.md
CHANGED
|
@@ -3,7 +3,7 @@
|
|
|
3
3
|
|
|
4
4
|
# @ankhorage/rules-design
|
|
5
5
|
|
|
6
|
-
         
|
|
7
7
|
|
|
8
8
|
Declarative catalog for reusable design rules.
|
|
9
9
|
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import type { UiNode } from '@ankhorage/contracts';
|
|
2
|
+
import type { WebsiteObservationDocument, WebsitePageRecognition, WebsiteRecognizedNode } from '@ankhorage/contracts/website';
|
|
3
|
+
/*** Recognizes source-linked canonical component trees from validated website observations. */
|
|
4
|
+
export declare function recognizeWebsiteStructure(document: WebsiteObservationDocument): readonly WebsitePageRecognition[];
|
|
5
|
+
export interface RecognizedTreeNode {
|
|
6
|
+
readonly node: WebsiteRecognizedNode;
|
|
7
|
+
readonly nodes: readonly WebsiteRecognizedNode[];
|
|
8
|
+
readonly uiNode: UiNode;
|
|
9
|
+
}
|
|
@@ -0,0 +1,209 @@
|
|
|
1
|
+
import { recognizeWebsiteStructureProps } from './recognizeWebsiteStructureProps';
|
|
2
|
+
import { recognizeWebsiteStructureSemanticComponentType } from './websiteStructureSemantics';
|
|
3
|
+
import { createWebsiteStructureTreeNode } from './websiteStructureTreeNodes';
|
|
4
|
+
/*** Recognizes source-linked canonical component trees from validated website observations. */
|
|
5
|
+
export function recognizeWebsiteStructure(document) {
|
|
6
|
+
return document.pages.map(recognizePage);
|
|
7
|
+
}
|
|
8
|
+
/*** Recognizes one page while retaining every source node in the canonical tree or node mapping. */
|
|
9
|
+
function recognizePage(page) {
|
|
10
|
+
const nodesBySourceRef = new Map(page.nodes.map((node) => [node.sourceRef, node]));
|
|
11
|
+
const childNodesByParent = createChildNodesByParent(page.nodes);
|
|
12
|
+
const rootNodes = page.nodes.filter((node) => node.parentSourceRef === null || !nodesBySourceRef.has(node.parentSourceRef));
|
|
13
|
+
const recognizedNodes = rootNodes.flatMap((node) => recognizeTreeNode(node, nodesBySourceRef, childNodesByParent, node.parentSourceRef, [], []));
|
|
14
|
+
const allRecognitions = page.nodes.reduce((recognitions, node) => containsSourceRef(recognitions, node.sourceRef)
|
|
15
|
+
? recognitions
|
|
16
|
+
: [
|
|
17
|
+
...recognitions,
|
|
18
|
+
...recognizeTreeNode(node, nodesBySourceRef, childNodesByParent, null, [], []),
|
|
19
|
+
], recognizedNodes);
|
|
20
|
+
return {
|
|
21
|
+
id: page.id,
|
|
22
|
+
nodes: allRecognitions.flatMap((recognition) => recognition.nodes),
|
|
23
|
+
path: page.path,
|
|
24
|
+
root: {
|
|
25
|
+
children: allRecognitions.map((recognition) => recognition.uiNode),
|
|
26
|
+
id: `${page.id}:root`,
|
|
27
|
+
type: 'Container',
|
|
28
|
+
},
|
|
29
|
+
url: page.url,
|
|
30
|
+
};
|
|
31
|
+
}
|
|
32
|
+
/*** Indexes observed children in DOM order for deterministic parent traversal. */
|
|
33
|
+
function createChildNodesByParent(nodes) {
|
|
34
|
+
const entries = nodes.reduce((childrenByParent, node) => {
|
|
35
|
+
if (node.parentSourceRef === null)
|
|
36
|
+
return childrenByParent;
|
|
37
|
+
const siblings = childrenByParent.get(node.parentSourceRef) ?? [];
|
|
38
|
+
return new Map(childrenByParent).set(node.parentSourceRef, [...siblings, node]);
|
|
39
|
+
}, new Map());
|
|
40
|
+
return new Map([...entries].map(([parentSourceRef, children]) => [
|
|
41
|
+
parentSourceRef,
|
|
42
|
+
[...children].sort(compareDomOrder),
|
|
43
|
+
]));
|
|
44
|
+
}
|
|
45
|
+
/*** Orders source nodes by their observed sibling position and stable source reference. */
|
|
46
|
+
function compareDomOrder(left, right) {
|
|
47
|
+
return (left.dom.childIndex - right.dom.childIndex || left.sourceRef.localeCompare(right.sourceRef));
|
|
48
|
+
}
|
|
49
|
+
/*** Recognizes one node and folds transparent wrappers into their meaningful descendants. */
|
|
50
|
+
function recognizeTreeNode(node, nodesBySourceRef, childNodesByParent, effectiveParentSourceRef, inheritedSourceRefs, ancestorSourceRefs) {
|
|
51
|
+
if (ancestorSourceRefs.includes(node.sourceRef)) {
|
|
52
|
+
return [];
|
|
53
|
+
}
|
|
54
|
+
const children = childNodesByParent.get(node.sourceRef) ?? [];
|
|
55
|
+
if (!isCyclicSourceRef(node, nodesBySourceRef) && isTransparentWrapper(node, children)) {
|
|
56
|
+
return children.flatMap((child) => recognizeTreeNode(child, nodesBySourceRef, childNodesByParent, effectiveParentSourceRef, [...inheritedSourceRefs, node.sourceRef], [...ancestorSourceRefs, node.sourceRef]));
|
|
57
|
+
}
|
|
58
|
+
const childRecognitions = children.flatMap((child) => recognizeTreeNode(child, nodesBySourceRef, childNodesByParent, node.sourceRef, [], [...ancestorSourceRefs, node.sourceRef]));
|
|
59
|
+
return [
|
|
60
|
+
createRecognizedTreeNode(node, nodesBySourceRef.get(effectiveParentSourceRef ?? '') ?? null, childNodesByParent, nodesBySourceRef, inheritedSourceRefs, childRecognitions),
|
|
61
|
+
];
|
|
62
|
+
}
|
|
63
|
+
/*** Combines component classification, source lineage, and child mappings into one canonical node. */
|
|
64
|
+
function createRecognizedTreeNode(node, parent, childNodesByParent, nodesBySourceRef, inheritedSourceRefs, children) {
|
|
65
|
+
const cyclic = isCyclicSourceRef(node, nodesBySourceRef);
|
|
66
|
+
const componentType = cyclic
|
|
67
|
+
? 'Unknown'
|
|
68
|
+
: recognizeComponentType(node, parent, childNodesByParent);
|
|
69
|
+
const props = recognizeWebsiteStructureProps(node);
|
|
70
|
+
return createWebsiteStructureTreeNode(node, componentType, [...inheritedSourceRefs, node.sourceRef], props, children, cyclic
|
|
71
|
+
? 'Source hierarchy contains a cycle.'
|
|
72
|
+
: availableObservation(node) === null
|
|
73
|
+
? 'No available rendered observation exists for this source node.'
|
|
74
|
+
: 'Visible source node has no canonical component mapping.');
|
|
75
|
+
}
|
|
76
|
+
/*** Tests whether a source reference participates in a parent-reference cycle. */
|
|
77
|
+
function isCyclicSourceRef(node, nodesBySourceRef) {
|
|
78
|
+
const visitedSourceRefs = new Set();
|
|
79
|
+
let currentSourceRef = node.sourceRef;
|
|
80
|
+
while (currentSourceRef !== null) {
|
|
81
|
+
if (visitedSourceRefs.has(currentSourceRef))
|
|
82
|
+
return currentSourceRef === node.sourceRef;
|
|
83
|
+
visitedSourceRefs.add(currentSourceRef);
|
|
84
|
+
currentSourceRef = nodesBySourceRef.get(currentSourceRef)?.parentSourceRef ?? null;
|
|
85
|
+
}
|
|
86
|
+
return false;
|
|
87
|
+
}
|
|
88
|
+
/*** Tests whether already emitted recognitions retain a source reference. */
|
|
89
|
+
function containsSourceRef(recognitions, sourceRef) {
|
|
90
|
+
return recognitions.some((recognition) => recognition.nodes.some((node) => node.sourceRefs.includes(sourceRef)));
|
|
91
|
+
}
|
|
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
|
+
/*** Maps observed DOM semantics and measured layout traits to already representable UI components. */
|
|
106
|
+
function recognizeComponentType(node, parent, childNodesByParent) {
|
|
107
|
+
const observation = availableObservation(node);
|
|
108
|
+
if (observation === null)
|
|
109
|
+
return 'Unknown';
|
|
110
|
+
const tagName = node.dom.tagName.toLowerCase();
|
|
111
|
+
const semanticType = recognizeWebsiteStructureSemanticComponentType(tagName);
|
|
112
|
+
if (semanticType !== null)
|
|
113
|
+
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
|
+
const { css } = observation;
|
|
123
|
+
if (css === null)
|
|
124
|
+
return 'Unknown';
|
|
125
|
+
if (css.display.includes('grid'))
|
|
126
|
+
return 'Grid';
|
|
127
|
+
if (css.display.includes('flex'))
|
|
128
|
+
return 'Flex';
|
|
129
|
+
return hasLayoutRole(observation) || hasSurfaceRole(observation) ? 'Container' : 'Unknown';
|
|
130
|
+
}
|
|
131
|
+
/*** Recognizes a card only when a measured sibling group shares explicit surface traits. */
|
|
132
|
+
function isGroupedCard(node, parent, childNodesByParent) {
|
|
133
|
+
if (parent === null || !isLayoutGroup(parent))
|
|
134
|
+
return false;
|
|
135
|
+
const siblings = meaningfulChildren(parent.sourceRef, childNodesByParent);
|
|
136
|
+
return siblings.length >= 2 && siblings.every(isCardSurface) && isCardSurface(node);
|
|
137
|
+
}
|
|
138
|
+
/*** Flattens transparent DOM wrappers before measuring the source siblings in a layout group. */
|
|
139
|
+
function meaningfulChildren(parentSourceRef, childNodesByParent) {
|
|
140
|
+
const children = childNodesByParent.get(parentSourceRef) ?? [];
|
|
141
|
+
return children.flatMap((child) => {
|
|
142
|
+
const nestedChildren = childNodesByParent.get(child.sourceRef) ?? [];
|
|
143
|
+
return isTransparentWrapper(child, nestedChildren)
|
|
144
|
+
? meaningfulChildren(child.sourceRef, childNodesByParent)
|
|
145
|
+
: [child];
|
|
146
|
+
});
|
|
147
|
+
}
|
|
148
|
+
/*** Tests whether a parent has measured Grid or Flex grouping semantics. */
|
|
149
|
+
function isLayoutGroup(node) {
|
|
150
|
+
const css = availableObservation(node)?.css;
|
|
151
|
+
return css === null || css === undefined ? false : /grid|flex/.test(css.display);
|
|
152
|
+
}
|
|
153
|
+
/*** Requires padding plus radius, border, or shadow so colored columns are not invented as cards. */
|
|
154
|
+
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)';
|
|
209
|
+
}
|
|
@@ -0,0 +1,3 @@
|
|
|
1
|
+
import type { WebsiteObservedNode, WebsiteRecognizedProp } from '@ankhorage/contracts/website';
|
|
2
|
+
/*** Retains text runs, links, media references, and heading level as source-linked structural props. */
|
|
3
|
+
export declare function recognizeWebsiteStructureProps(node: WebsiteObservedNode): readonly WebsiteRecognizedProp[];
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
/*** Retains text runs, links, media references, and heading level as source-linked structural props. */
|
|
2
|
+
export function recognizeWebsiteStructureProps(node) {
|
|
3
|
+
const textRuns = node.textRuns.map((textRun) => ({
|
|
4
|
+
end: textRun.end,
|
|
5
|
+
sourceRef: textRun.sourceRef,
|
|
6
|
+
start: textRun.start,
|
|
7
|
+
text: textRun.text,
|
|
8
|
+
}));
|
|
9
|
+
const links = node.links.map((link) => ({
|
|
10
|
+
label: link.label,
|
|
11
|
+
sourceRef: link.sourceRef,
|
|
12
|
+
url: link.url,
|
|
13
|
+
}));
|
|
14
|
+
const media = node.media.map((item) => ({
|
|
15
|
+
alt: item.alt,
|
|
16
|
+
assetId: item.assetId,
|
|
17
|
+
kind: item.kind,
|
|
18
|
+
sourceRef: item.sourceRef,
|
|
19
|
+
url: item.url,
|
|
20
|
+
}));
|
|
21
|
+
const headingLevel = headingLevelFor(node.dom.tagName);
|
|
22
|
+
return [
|
|
23
|
+
...(textRuns.length === 0 ? [] : [recognizedProp('textRuns', textRuns)]),
|
|
24
|
+
...(links.length === 0 ? [] : [recognizedProp('links', links)]),
|
|
25
|
+
...(media.length === 0 ? [] : [recognizedProp('media', media)]),
|
|
26
|
+
...(headingLevel === null ? [] : [recognizedProp('level', headingLevel)]),
|
|
27
|
+
];
|
|
28
|
+
}
|
|
29
|
+
/*** Creates one serializable recognition prop while retaining the exact source value. */
|
|
30
|
+
function recognizedProp(name, value) {
|
|
31
|
+
return { name, originalValues: [value], value };
|
|
32
|
+
}
|
|
33
|
+
/*** Extracts an explicit heading level only from an observed heading tag. */
|
|
34
|
+
function headingLevelFor(tagName) {
|
|
35
|
+
return /^h[1-6]$/i.test(tagName) ? Number(tagName[1]) : null;
|
|
36
|
+
}
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
/*** Maps explicit HTML semantics without relying on framework or page-builder selectors. */
|
|
2
|
+
export function recognizeWebsiteStructureSemanticComponentType(tagName) {
|
|
3
|
+
if (/^h[1-6]$/.test(tagName))
|
|
4
|
+
return 'Heading';
|
|
5
|
+
return semanticComponentTypes.find(([name]) => name === tagName)?.[1] ?? null;
|
|
6
|
+
}
|
|
7
|
+
const semanticComponentTypes = [
|
|
8
|
+
['a', 'Link'],
|
|
9
|
+
['article', 'Container'],
|
|
10
|
+
['audio', 'Media'],
|
|
11
|
+
['body', 'Container'],
|
|
12
|
+
['blockquote', 'RichText'],
|
|
13
|
+
['button', 'Button'],
|
|
14
|
+
['footer', 'Footer'],
|
|
15
|
+
['form', 'Form'],
|
|
16
|
+
['header', 'Header'],
|
|
17
|
+
['iframe', 'Media'],
|
|
18
|
+
['img', 'Image'],
|
|
19
|
+
['label', 'RichText'],
|
|
20
|
+
['li', 'ListItem'],
|
|
21
|
+
['main', 'Container'],
|
|
22
|
+
['ol', 'List'],
|
|
23
|
+
['p', 'RichText'],
|
|
24
|
+
['section', 'Section'],
|
|
25
|
+
['ul', 'List'],
|
|
26
|
+
['video', 'Media'],
|
|
27
|
+
];
|
|
@@ -0,0 +1,4 @@
|
|
|
1
|
+
import type { WebsiteObservedNode, WebsiteRecognizedProp } from '@ankhorage/contracts/website';
|
|
2
|
+
import type { RecognizedTreeNode } from './recognizeWebsiteStructure';
|
|
3
|
+
/*** Creates a recognized tree node and retains all descendant source mappings. */
|
|
4
|
+
export declare function createWebsiteStructureTreeNode(node: WebsiteObservedNode, componentType: string, sourceRefs: readonly string[], props: readonly WebsiteRecognizedProp[], children: readonly RecognizedTreeNode[], unresolvedReason: string): RecognizedTreeNode;
|
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
/*** Creates a recognized tree node and retains all descendant source mappings. */
|
|
2
|
+
export function createWebsiteStructureTreeNode(node, componentType, sourceRefs, props, children, unresolvedReason) {
|
|
3
|
+
const unresolved = componentType === 'Unknown';
|
|
4
|
+
const recognizedNode = {
|
|
5
|
+
componentType,
|
|
6
|
+
confidence: unresolved ? 0 : confidenceFor(componentType),
|
|
7
|
+
id: node.sourceRef,
|
|
8
|
+
props,
|
|
9
|
+
responsive: [],
|
|
10
|
+
sourceRefs,
|
|
11
|
+
status: unresolved ? 'unresolved' : 'recognized',
|
|
12
|
+
unresolved: unresolved ? { reason: unresolvedReason, sourceRefs } : null,
|
|
13
|
+
};
|
|
14
|
+
return {
|
|
15
|
+
node: recognizedNode,
|
|
16
|
+
nodes: [recognizedNode, ...children.flatMap((child) => child.nodes)],
|
|
17
|
+
uiNode: createWebsiteStructureUiNode(node.sourceRef, componentType, props, children),
|
|
18
|
+
};
|
|
19
|
+
}
|
|
20
|
+
/*** Creates a stable source-derived UI node with ordered recognized children. */
|
|
21
|
+
function createWebsiteStructureUiNode(id, componentType, props, children) {
|
|
22
|
+
const uiProps = Object.fromEntries(props.map((prop) => [prop.name, prop.value]));
|
|
23
|
+
return {
|
|
24
|
+
...(children.length === 0 ? {} : { children: children.map((child) => child.uiNode) }),
|
|
25
|
+
id,
|
|
26
|
+
...(props.length === 0 ? {} : { props: uiProps }),
|
|
27
|
+
type: componentType,
|
|
28
|
+
};
|
|
29
|
+
}
|
|
30
|
+
/*** Assigns bounded confidence from the evidence class rather than an aesthetic assessment. */
|
|
31
|
+
function confidenceFor(componentType) {
|
|
32
|
+
if (componentType === 'Grid' || componentType === 'Flex')
|
|
33
|
+
return 0.98;
|
|
34
|
+
if (componentType === 'Card')
|
|
35
|
+
return 0.9;
|
|
36
|
+
if (componentType === 'Container')
|
|
37
|
+
return 0.8;
|
|
38
|
+
return 1;
|
|
39
|
+
}
|
package/dist/index.d.ts
CHANGED
|
@@ -6,6 +6,7 @@ export { createDesignRuleProvider } from './features/provider/designRuleProvider
|
|
|
6
6
|
export { selectDesignRuleProfile } from './features/provider/selectDesignRuleProfile';
|
|
7
7
|
export { recognizeWebsiteDesignProperties } from './features/recognition/recognizeWebsiteDesignProperties';
|
|
8
8
|
export { createWebsiteAssessmentRuleSet } from './features/website-assessment/createWebsiteAssessmentRuleSet';
|
|
9
|
+
export { recognizeWebsiteStructure } from './features/website-recognition/recognizeWebsiteStructure';
|
|
9
10
|
export type { DesignAssessmentKind, DesignRuleCatalogEntry, DesignRuleCatalogFilter, DesignRuleEvidence, DesignRulePlanningManifest, DesignRuleProfile, DesignRuleProviderManifest, DesignRuleScope, DesignRuleStatus, } from './types/designRuleCatalog';
|
|
10
11
|
export type { DesignContext, DesignRuleProfileSelection, DesignRuleProvider, DesignRuleProviderOptions, } from './types/designRuleProvider';
|
|
11
12
|
export type { WebsiteAssessmentRuleOptions } from './types/websiteAssessment';
|
package/dist/index.js
CHANGED
|
@@ -6,3 +6,4 @@ export { createDesignRuleProvider } from './features/provider/designRuleProvider
|
|
|
6
6
|
export { selectDesignRuleProfile } from './features/provider/selectDesignRuleProfile';
|
|
7
7
|
export { recognizeWebsiteDesignProperties } from './features/recognition/recognizeWebsiteDesignProperties';
|
|
8
8
|
export { createWebsiteAssessmentRuleSet } from './features/website-assessment/createWebsiteAssessmentRuleSet';
|
|
9
|
+
export { recognizeWebsiteStructure } from './features/website-recognition/recognizeWebsiteStructure';
|