@ankhorage/rules-design 0.2.2 → 0.3.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 CHANGED
@@ -1,5 +1,11 @@
1
1
  # Changelog
2
2
 
3
+ ## 0.3.0
4
+
5
+ ### Minor Changes
6
+
7
+ - c1bd0c9: Support normalized versioned facts for Typography and Heading rule evaluation.
8
+
3
9
  ## 0.2.2
4
10
 
5
11
  ### Patch 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.2.2](././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.3.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)
7
7
 
8
8
  Declarative catalog for reusable design rules.
9
9
 
@@ -0,0 +1,18 @@
1
+ import type { TypographyObservation } from '../../types/typography';
2
+ /*** Creates the shared completeness and viewport grouping operations for Typography evidence. */
3
+ export declare function createTypographyObservationTools(): {
4
+ measurementsComplete: typeof measurementsComplete;
5
+ orderedHeadings: typeof orderedHeadings;
6
+ viewports: typeof viewports;
7
+ };
8
+ type TypographyMeasurement = keyof TypographyObservation;
9
+ /*** Checks required measurements and document-order uniqueness when a rule needs it. */
10
+ declare function measurementsComplete(observations: readonly TypographyObservation[], measurements: readonly TypographyMeasurement[]): boolean;
11
+ /*** Groups observations by responsive viewport so rendered variants remain independent. */
12
+ declare function viewports(observations: readonly TypographyObservation[]): readonly (readonly TypographyObservation[])[];
13
+ /*** Sorts complete heading observations by explicit document order. */
14
+ declare function orderedHeadings(observations: readonly TypographyObservation[]): readonly (TypographyObservation & {
15
+ readonly documentOrder: number;
16
+ readonly headingLevel: number;
17
+ })[];
18
+ export {};
@@ -0,0 +1,53 @@
1
+ /*** Creates the shared completeness and viewport grouping operations for Typography evidence. */
2
+ export function createTypographyObservationTools() {
3
+ return { measurementsComplete, orderedHeadings, viewports };
4
+ }
5
+ /*** Checks required measurements and document-order uniqueness when a rule needs it. */
6
+ function measurementsComplete(observations, measurements) {
7
+ return (observations.every((observation) => measurements.every((measurement) => measurementAvailable(observation, measurement))) &&
8
+ (!measurements.includes('documentOrder') ||
9
+ viewports(observations).every((viewport) => uniqueDocumentOrder(viewport))));
10
+ }
11
+ /*** Checks one named observation measurement without indexing dynamic external property names. */
12
+ function measurementAvailable(observation, measurement) {
13
+ switch (measurement) {
14
+ case 'documentOrder':
15
+ return observation.documentOrder !== null;
16
+ case 'headingLevel':
17
+ return observation.headingLevel !== null;
18
+ case 'marginAfter':
19
+ return observation.marginAfter !== null;
20
+ case 'marginBefore':
21
+ return observation.marginBefore !== null;
22
+ case 'paragraphMeasure':
23
+ return observation.paragraphMeasure !== null;
24
+ case 'responsiveRole':
25
+ return observation.responsiveRole !== null;
26
+ case 'semanticStyle':
27
+ return observation.semanticStyle !== null;
28
+ case 'textClipped':
29
+ return observation.textClipped !== null;
30
+ default:
31
+ return true;
32
+ }
33
+ }
34
+ /*** Groups observations by responsive viewport so rendered variants remain independent. */
35
+ function viewports(observations) {
36
+ return Object.values(Object.groupBy(observations, (observation) => observation.viewport)).flatMap((viewport) => (viewport === undefined ? [] : [viewport]));
37
+ }
38
+ /*** Confirms that every heading in one viewport has a distinct document position. */
39
+ function uniqueDocumentOrder(observations) {
40
+ const documentOrders = observations.map((observation) => observation.documentOrder);
41
+ return (documentOrders.every((order) => order !== null) &&
42
+ new Set(documentOrders).size === documentOrders.length);
43
+ }
44
+ /*** Sorts complete heading observations by explicit document order. */
45
+ function orderedHeadings(observations) {
46
+ return observations
47
+ .filter(hasDocumentOrderAndHeadingLevel)
48
+ .toSorted((left, right) => left.documentOrder - right.documentOrder);
49
+ }
50
+ /*** Confirms that an observation can participate in a document heading hierarchy. */
51
+ function hasDocumentOrderAndHeadingLevel(observation) {
52
+ return observation.documentOrder !== null && observation.headingLevel !== null;
53
+ }
@@ -0,0 +1,6 @@
1
+ import type { RuleSet } from '@ankhorage/rules';
2
+ import type { DesignContext } from '../../types/designRuleProvider';
3
+ import type { TypographyRulePolicy } from '../../types/typography';
4
+ export type { TypographyRulePolicy } from '../../types/typography';
5
+ /*** Creates the independent Typography and Heading RuleSet from explicit serialized-fact policy. */
6
+ export declare function createTypographyRuleSet(policy: TypographyRulePolicy): RuleSet<DesignContext>;
@@ -0,0 +1,114 @@
1
+ import { createTypographyObservationTools } from './createTypographyObservationTools';
2
+ import { parseTypographyObservation } from './parseTypographyObservation';
3
+ import { validateTypographyRulePolicy } from './validateTypographyRulePolicy';
4
+ const typographyObservationTools = createTypographyObservationTools();
5
+ /*** Creates the independent Typography and Heading RuleSet from explicit serialized-fact policy. */
6
+ export function createTypographyRuleSet(policy) {
7
+ validateTypographyRulePolicy(policy);
8
+ return {
9
+ id: 'ankhorage.rules-design.typography',
10
+ rules: ruleDefinitions.map((definition) => createRule(definition, policy)),
11
+ };
12
+ }
13
+ const ruleDefinitions = [
14
+ definition('design.typography.font-family', 'Typography uses configured font families.', (facts, policy) => facts.filter((fact) => !policy.allowedFontFamilies.includes(fact.fontFamily)), requiredMeasurements('fontFamily')),
15
+ definition('design.typography.scale', 'Typography sizes use the configured scale.', (facts, policy) => facts.filter((fact) => !policy.allowedFontSizes.includes(fact.fontSize)), requiredMeasurements('fontSize')),
16
+ definition('design.typography.weight', 'Typography uses configured font weights.', (facts, policy) => facts.filter((fact) => !policy.allowedFontWeights.includes(fact.fontWeight)), requiredMeasurements('fontWeight')),
17
+ definition('design.typography.line-height', 'Typography uses configured line heights.', (facts, policy) => facts.filter((fact) => !policy.allowedLineHeights.includes(fact.lineHeight)), requiredMeasurements('lineHeight')),
18
+ definition('design.typography.letter-spacing', 'Typography uses configured letter spacing.', (facts, policy) => facts.filter((fact) => !policy.allowedLetterSpacings.includes(fact.letterSpacing)), requiredMeasurements('letterSpacing')),
19
+ definition('design.typography.paragraph-measure', 'Paragraphs stay within the configured readable measure.', (facts, policy) => facts.filter((fact) => fact.paragraphMeasure !== null &&
20
+ (fact.paragraphMeasure < policy.minimumParagraphMeasure ||
21
+ fact.paragraphMeasure > policy.maximumParagraphMeasure)), requiredMeasurements('paragraphMeasure'), 'warning'),
22
+ definition('design.typography.body-minimum', 'Body text meets the configured minimum font size.', (facts, policy) => facts.filter((fact) => fact.headingLevel === null && fact.fontSize < policy.minimumBodyFontSize), () => true),
23
+ definition('design.typography.responsive-scale', 'Responsive text sizes follow the configured scale for their role.', (facts, policy) => facts.filter((fact) => fact.responsiveRole !== null &&
24
+ !configuredValues(policy.responsiveFontSizes, fact.responsiveRole).includes(fact.fontSize)), requiredMeasurements('responsiveRole', 'fontSize')),
25
+ definition('design.heading.h1-presence', 'A page contains the configured minimum number of H1 headings.', (facts, policy) => typographyObservationTools
26
+ .viewports(facts)
27
+ .flatMap((factsForViewport) => factsForViewport.filter((fact) => fact.headingLevel === 1).length < policy.minimumH1Count
28
+ ? factsForViewport.slice(0, 1)
29
+ : []), requiredMeasurements('headingLevel', 'viewport'), 'error', 'design.heading-facts'),
30
+ definition('design.heading.h1-count', 'A page does not exceed the configured number of H1 headings.', (facts, policy) => typographyObservationTools.viewports(facts).flatMap((factsForViewport) => {
31
+ const h1Headings = typographyObservationTools
32
+ .orderedHeadings(factsForViewport)
33
+ .filter((fact) => fact.headingLevel === 1);
34
+ return h1Headings.slice(policy.maximumH1Count);
35
+ }), requiredMeasurements('documentOrder', 'headingLevel', 'viewport'), 'error', 'design.heading-facts'),
36
+ definition('design.heading.level-order', 'Heading levels do not skip hierarchy levels.', (facts) => typographyObservationTools
37
+ .viewports(facts)
38
+ .flatMap((factsForViewport) => typographyObservationTools
39
+ .orderedHeadings(factsForViewport)
40
+ .filter((fact, index, ordered) => index > 0 && fact.headingLevel > (ordered[index - 1]?.headingLevel ?? 0) + 1)), requiredMeasurements('documentOrder', 'headingLevel'), 'error', 'design.heading-facts'),
41
+ definition('design.heading.semantic-style', 'Heading semantics use a configured visual style.', (facts, policy) => facts.filter((fact) => fact.semanticStyle !== null &&
42
+ !configuredValues(policy.allowedSemanticStyles, `h${fact.headingLevel}`).includes(fact.semanticStyle)), requiredMeasurements('headingLevel', 'semanticStyle'), 'error', 'design.heading-facts'),
43
+ definition('design.heading.spacing-before', 'Headings use configured preceding spacing.', (facts, policy) => facts.filter((fact) => fact.marginBefore !== null && !policy.allowedSpacingBefore.includes(fact.marginBefore)), requiredMeasurements('headingLevel', 'marginBefore'), 'error', 'design.heading-facts'),
44
+ definition('design.heading.spacing-after', 'Headings use configured following spacing.', (facts, policy) => facts.filter((fact) => fact.marginAfter !== null && !policy.allowedSpacingAfter.includes(fact.marginAfter)), requiredMeasurements('headingLevel', 'marginAfter'), 'error', 'design.heading-facts'),
45
+ definition('design.heading.text-clipping', 'Heading text is not clipped in the rendered layout.', (facts) => facts.filter((fact) => fact.textClipped === true), requiredMeasurements('headingLevel', 'textClipped'), 'error', 'design.heading-facts'),
46
+ ];
47
+ /*** Builds one pure generic Rules rule from a Typography fact predicate. */
48
+ function createRule(definition, policy) {
49
+ return {
50
+ defaultSeverity: definition.severity,
51
+ dependencies: [],
52
+ evaluate: ({ context, scope }) => {
53
+ const [complete, observations] = typographyEvidence(context, definition.capability, scope);
54
+ if (!complete || observations.length === 0 || !definition.measurementsComplete(observations))
55
+ return incomplete(definition.id);
56
+ const violations = definition.evaluate(observations, policy);
57
+ return violations.length === 0
58
+ ? { findings: [], status: 'PASS' }
59
+ : {
60
+ findings: violations.map((fact) => violationFinding(definition.id, fact)),
61
+ status: 'FAIL',
62
+ };
63
+ },
64
+ identity: { id: definition.id, version: '1.0.0' },
65
+ requiredCapabilities: [definition.capability],
66
+ summary: definition.summary,
67
+ };
68
+ }
69
+ /*** Creates a Typography rule definition with its capability inferred from its stable ID. */
70
+ function definition(id, summary, evaluate, measurementsComplete, severity = 'error', capability = 'design.typography-facts') {
71
+ return { capability, evaluate, id, measurementsComplete, severity, summary };
72
+ }
73
+ /*** Reads scoped Typography facts without discarding malformed or unavailable evidence. */
74
+ function typographyEvidence(context, capability, scope) {
75
+ const factObservations = (context.facts ?? [])
76
+ .filter((fact) => fact.kind === capability && fact.scope.id === scope.id && fact.scope.kind === scope.kind)
77
+ .map((fact) => fact.status === 'available' ? parseTypographyObservation(fact.value, fact.id) : []);
78
+ return [
79
+ factObservations.every((observations) => observations.length > 0),
80
+ factObservations.flat(),
81
+ ];
82
+ }
83
+ /*** Returns an explicit incomplete outcome when required measurements cannot support a verdict. */
84
+ function incomplete(ruleId) {
85
+ return { findings: [missingEvidenceFinding(ruleId)], status: 'INCOMPLETE' };
86
+ }
87
+ /*** Produces a serializable incomplete finding when a rule has no valid measured observation. */
88
+ function missingEvidenceFinding(ruleId) {
89
+ return {
90
+ evidence: { reason: 'No valid normalized Typography observation was supplied.' },
91
+ message: `Rule "${ruleId}" is incomplete because Typography evidence is missing.`,
92
+ ruleId,
93
+ severity: 'info',
94
+ subjects: [{ id: 'design-context', kind: 'design-context' }],
95
+ };
96
+ }
97
+ /*** Produces a serializable finding for one measured Typography policy violation. */
98
+ function violationFinding(ruleId, fact) {
99
+ return {
100
+ evidence: { observationId: fact.id, viewport: fact.viewport },
101
+ message: `Rule "${ruleId}" is violated by Typography observation "${fact.id}".`,
102
+ ruleId,
103
+ severity: 'error',
104
+ subjects: [{ id: fact.id, kind: 'typography-observation' }],
105
+ };
106
+ }
107
+ /*** Reads a configured allow-list without treating an unknown role as allowed. */
108
+ function configuredValues(values, key) {
109
+ return Object.entries(values).find(([candidate]) => candidate === key)?.[1] ?? [];
110
+ }
111
+ /*** Builds a completeness predicate from one frozen rule's required measurements. */
112
+ function requiredMeasurements(...keys) {
113
+ return (observations) => typographyObservationTools.measurementsComplete(observations, keys);
114
+ }
@@ -0,0 +1,3 @@
1
+ import type { TypographyObservation } from '../../types/typography';
2
+ /*** Parses one available serialized fact into a normalized Typography observation. */
3
+ export declare function parseTypographyObservation(value: unknown, id: string): readonly TypographyObservation[];
@@ -0,0 +1,62 @@
1
+ import { isRecord } from '@ankhorage/utility/object';
2
+ /*** Parses one available serialized fact into a normalized Typography observation. */
3
+ export function parseTypographyObservation(value, id) {
4
+ if (!isRecord(value) ||
5
+ !isString(value.fontFamily) ||
6
+ !isNumber(value.fontSize) ||
7
+ !isString(value.fontWeight) ||
8
+ !isNumber(value.letterSpacing) ||
9
+ !isNumber(value.lineHeight) ||
10
+ !isString(value.viewport))
11
+ return [];
12
+ const headingLevel = nullableHeadingLevel(value.headingLevel);
13
+ if (headingLevel === undefined)
14
+ return [];
15
+ return [
16
+ {
17
+ fontFamily: value.fontFamily,
18
+ fontSize: value.fontSize,
19
+ fontWeight: value.fontWeight,
20
+ documentOrder: nullableNumber(value.documentOrder),
21
+ headingLevel: headingLevel ?? null,
22
+ id,
23
+ letterSpacing: value.letterSpacing,
24
+ lineHeight: value.lineHeight,
25
+ marginAfter: nullableNumber(value.marginAfter),
26
+ marginBefore: nullableNumber(value.marginBefore),
27
+ paragraphMeasure: nullableNumber(value.paragraphMeasure),
28
+ responsiveRole: nullableString(value.responsiveRole),
29
+ semanticStyle: nullableString(value.semanticStyle),
30
+ textClipped: nullableBoolean(value.textClipped),
31
+ viewport: value.viewport,
32
+ },
33
+ ];
34
+ }
35
+ /*** Narrows an unknown serialized value to a finite number. */
36
+ function isNumber(value) {
37
+ return typeof value === 'number' && Number.isFinite(value);
38
+ }
39
+ /*** Narrows an optional serialized value to a nullable boolean. */
40
+ function nullableBoolean(value) {
41
+ return value === undefined || value === null ? null : typeof value === 'boolean' ? value : null;
42
+ }
43
+ /*** Narrows an optional serialized value to a valid nullable heading level. */
44
+ function nullableHeadingLevel(value) {
45
+ return value === undefined || value === null
46
+ ? null
47
+ : isNumber(value) && Number.isInteger(value) && value >= 1 && value <= 6
48
+ ? value
49
+ : undefined;
50
+ }
51
+ /*** Narrows an optional serialized value to a nullable finite number. */
52
+ function nullableNumber(value) {
53
+ return value === undefined || value === null ? null : isNumber(value) ? value : null;
54
+ }
55
+ /*** Narrows an optional serialized value to a nullable string. */
56
+ function nullableString(value) {
57
+ return value === undefined || value === null ? null : isString(value) ? value : null;
58
+ }
59
+ /*** Narrows an unknown serialized value to a string. */
60
+ function isString(value) {
61
+ return typeof value === 'string';
62
+ }
@@ -0,0 +1,3 @@
1
+ import type { TypographyRulePolicy } from '../../types/typography';
2
+ /*** Rejects malformed policy before rule construction can produce ambiguous verdicts. */
3
+ export declare function validateTypographyRulePolicy(policy: TypographyRulePolicy): void;
@@ -0,0 +1,68 @@
1
+ /*** Rejects malformed policy before rule construction can produce ambiguous verdicts. */
2
+ export function validateTypographyRulePolicy(policy) {
3
+ if (invalidTypographyRulePolicy(policy)) {
4
+ throw new Error('Typography rule policy must contain complete, internally consistent measurements.');
5
+ }
6
+ }
7
+ /*** Checks every policy invariant required by the Typography rule family. */
8
+ function invalidTypographyRulePolicy(policy) {
9
+ return (!hasNonEmptyStrings(policy.allowedFontFamilies) ||
10
+ !hasPositiveNumbers(policy.allowedFontSizes) ||
11
+ !hasNonEmptyStrings(policy.allowedFontWeights) ||
12
+ !hasFiniteNumbers(policy.allowedLetterSpacings) ||
13
+ !hasPositiveNumbers(policy.allowedLineHeights) ||
14
+ !hasNonNegativeNumbers(policy.allowedSpacingAfter) ||
15
+ !hasNonNegativeNumbers(policy.allowedSpacingBefore) ||
16
+ !hasConfiguredValues(policy.allowedSemanticStyles, hasNonEmptyStrings) ||
17
+ !hasConfiguredValues(policy.responsiveFontSizes, hasPositiveNumbers) ||
18
+ !hasValidH1Counts(policy) ||
19
+ !hasValidTypographyThresholds(policy));
20
+ }
21
+ /*** Checks that H1 count bounds are non-negative integers in ascending order. */
22
+ function hasValidH1Counts(policy) {
23
+ return (Number.isInteger(policy.minimumH1Count) &&
24
+ Number.isInteger(policy.maximumH1Count) &&
25
+ policy.minimumH1Count >= 0 &&
26
+ policy.maximumH1Count >= policy.minimumH1Count);
27
+ }
28
+ /*** Checks positive Typography thresholds and paragraph-measure bounds. */
29
+ function hasValidTypographyThresholds(policy) {
30
+ return (isPositiveFiniteNumber(policy.minimumBodyFontSize) &&
31
+ isPositiveFiniteNumber(policy.minimumParagraphMeasure) &&
32
+ isPositiveFiniteNumber(policy.maximumParagraphMeasure) &&
33
+ policy.maximumParagraphMeasure >= policy.minimumParagraphMeasure);
34
+ }
35
+ /*** Checks a non-empty serializable string allow-list. */
36
+ function hasNonEmptyStrings(values) {
37
+ return (Array.isArray(values) &&
38
+ values.length > 0 &&
39
+ values.every((value) => typeof value === 'string' && value.length > 0));
40
+ }
41
+ /*** Checks a non-empty serializable positive numeric allow-list. */
42
+ function hasPositiveNumbers(values) {
43
+ return Array.isArray(values) && values.length > 0 && values.every(isPositiveFiniteNumber);
44
+ }
45
+ /*** Checks a non-empty serializable finite numeric allow-list. */
46
+ function hasFiniteNumbers(values) {
47
+ return (Array.isArray(values) &&
48
+ values.length > 0 &&
49
+ values.every((value) => typeof value === 'number' && Number.isFinite(value)));
50
+ }
51
+ /*** Checks a non-empty serializable non-negative numeric allow-list. */
52
+ function hasNonNegativeNumbers(values) {
53
+ return (Array.isArray(values) &&
54
+ values.length > 0 &&
55
+ values.every((value) => typeof value === 'number' && Number.isFinite(value) && value >= 0));
56
+ }
57
+ /*** Checks a finite positive measurement. */
58
+ function isPositiveFiniteNumber(value) {
59
+ return typeof value === 'number' && Number.isFinite(value) && value > 0;
60
+ }
61
+ /*** Checks every named policy role supplies a non-empty valid allow-list. */
62
+ function hasConfiguredValues(values, validate) {
63
+ return (typeof values === 'object' &&
64
+ values !== null &&
65
+ !Array.isArray(values) &&
66
+ Object.keys(values).length > 0 &&
67
+ Object.entries(values).every(([key, value]) => key.length > 0 && validate(value)));
68
+ }
@@ -1,3 +1,4 @@
1
+ import type { FactEnvelope } from '@ankhorage/contracts/rules';
1
2
  import type { RuleSet } from '@ankhorage/rules';
2
3
  /*** One provider-neutral design observation supplied by a Design context. */
3
4
  export interface DesignEvidence {
@@ -7,6 +8,7 @@ export interface DesignEvidence {
7
8
  /*** The minimal context shared by Design rules without prescribing its source. */
8
9
  export interface DesignContext {
9
10
  readonly evidence: readonly DesignEvidence[];
11
+ readonly facts?: readonly FactEnvelope[];
10
12
  }
11
13
  /*** The public identity and generic Rules contribution for the Design provider. */
12
14
  export interface DesignRuleProvider {
@@ -0,0 +1,35 @@
1
+ /** One normalized, provider-neutral rendered Typography observation. */
2
+ export interface TypographyObservation {
3
+ readonly documentOrder: number | null;
4
+ readonly fontFamily: string;
5
+ readonly fontSize: number;
6
+ readonly fontWeight: string;
7
+ readonly headingLevel: number | null;
8
+ readonly id: string;
9
+ readonly letterSpacing: number;
10
+ readonly lineHeight: number;
11
+ readonly marginAfter: number | null;
12
+ readonly marginBefore: number | null;
13
+ readonly paragraphMeasure: number | null;
14
+ readonly responsiveRole: string | null;
15
+ readonly semanticStyle: string | null;
16
+ readonly textClipped: boolean | null;
17
+ readonly viewport: string;
18
+ }
19
+ /** Explicit allow-lists and thresholds used to evaluate Typography observations. */
20
+ export interface TypographyRulePolicy {
21
+ readonly allowedFontFamilies: readonly string[];
22
+ readonly allowedFontSizes: readonly number[];
23
+ readonly allowedFontWeights: readonly string[];
24
+ readonly allowedLetterSpacings: readonly number[];
25
+ readonly allowedLineHeights: readonly number[];
26
+ readonly allowedSemanticStyles: Readonly<Record<string, readonly string[]>>;
27
+ readonly allowedSpacingAfter: readonly number[];
28
+ readonly allowedSpacingBefore: readonly number[];
29
+ readonly maximumH1Count: number;
30
+ readonly maximumParagraphMeasure: number;
31
+ readonly minimumBodyFontSize: number;
32
+ readonly minimumH1Count: number;
33
+ readonly minimumParagraphMeasure: number;
34
+ readonly responsiveFontSizes: Readonly<Record<string, readonly number[]>>;
35
+ }
File without changes
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ankhorage/rules-design",
3
- "version": "0.2.2",
3
+ "version": "0.3.0",
4
4
  "description": "Declarative catalog for reusable design rules.",
5
5
  "license": "MIT",
6
6
  "homepage": "https://github.com/ankhorage/rules-design#readme",