@redocly/config-rules-builder 0.0.1 → 0.1.0

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+import { AssertionKey, CasingStyle } from './types';
+export declare const CASING_STYLES: CasingStyle[];
+export declare const NODE_TYPES: string[];
+export type AssertionValueKind = 'casing' | 'text' | 'regex' | 'stringList' | 'number' | 'boolean' | 'refValue';
+export interface AssertionMeta {
+    key: AssertionKey;
+    kind: AssertionValueKind;
+    propertyMode: 'forbidden' | 'required' | 'either';
+    hint: string;
+}
+export declare const ASSERTION_META: AssertionMeta[];
+export declare const ASSERTION_META_BY_KEY: Record<string, AssertionMeta>;
+export declare const MESSAGE_PLACEHOLDERS: string[];

package/dist/default-spec.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_SPEC: string;

package/dist/engine/evaluate.d.ts

@@ -0,0 +1,2 @@
+import { EvaluationResult, NamedRule } from '../types';
+export declare function evaluateRules(specText: string, rules: NamedRule[], fileName?: string): Promise<EvaluationResult>;

package/dist/engine/offsets.d.ts

@@ -0,0 +1,11 @@
+export interface CharRange {
+    from: number;
+    to: number;
+}
+export interface PointerRangeResolver {
+    resolve(pointer: string, reportOnKey: boolean): CharRange | undefined;
+    lineAt(offset: number): number;
+    lineCount: number;
+    lineRange(line: number): CharRange;
+}
+export declare function createPointerRangeResolver(specText: string): PointerRangeResolver;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { RulesBuilder, type RulesBuilderProps } from './components/RulesBuilder';
+export { evaluateRules } from './engine/evaluate';
+export { serializeRules } from './yaml/serialize';
+export { parseImportedRules, type ImportResult } from './yaml/parse';
+export { DEFAULT_SPEC } from './default-spec';
+export type { AssertionKey, AssertionObject, CasingStyle, ConfigurableRule, EvaluationResult, HostAdapters, MatchedNode, NamedRule, ProblemInfo, Severity, SubjectObject, WhereObject, } from './types';

package/dist/normalize.d.ts

@@ -0,0 +1,43 @@
+import { ConfigurableRule, SubjectObject } from './types';
+export declare function pruneRule(rule: ConfigurableRule): {
+    severity?: "warn" | "off" | undefined;
+    reference?: string | undefined;
+    suggest?: string[] | undefined;
+    message?: string | undefined;
+    where?: {
+        subject: {
+            matchParentKeys?: string | undefined;
+            filterOutParentKeys?: string[] | undefined;
+            filterInParentKeys?: string[] | undefined;
+            property?: string | string[] | undefined;
+            type: string;
+        };
+        assertions: import('./types').AssertionObject;
+    }[] | undefined;
+    subject: {
+        matchParentKeys?: string | undefined;
+        filterOutParentKeys?: string[] | undefined;
+        filterInParentKeys?: string[] | undefined;
+        property?: string | string[] | undefined;
+        type: string;
+    };
+    assertions: import('./types').AssertionObject;
+};
+export declare function pruneWhere(where: ConfigurableRule['where']): {
+    subject: {
+        matchParentKeys?: string | undefined;
+        filterOutParentKeys?: string[] | undefined;
+        filterInParentKeys?: string[] | undefined;
+        property?: string | string[] | undefined;
+        type: string;
+    };
+    assertions: import('./types').AssertionObject;
+}[] | undefined;
+export declare function cleanSubject(subject: SubjectObject): {
+    matchParentKeys?: string | undefined;
+    filterOutParentKeys?: string[] | undefined;
+    filterInParentKeys?: string[] | undefined;
+    property?: string | string[] | undefined;
+    type: string;
+};
+export declare function ruleId(name: string, index: number): string;

package/dist/state.d.ts

@@ -0,0 +1,10 @@
+import { ConfigurableRule, NamedRule } from './types';
+export interface RuleEntry {
+    id: string;
+    name: string;
+    rule: ConfigurableRule;
+}
+export declare function makeId(): string;
+export declare function toNamedRules(entries: RuleEntry[]): NamedRule[];
+export declare function createRuleEntry(named: NamedRule): RuleEntry;
+export declare function createDefaultRule(existingNames: string[]): RuleEntry;

package/dist/styles.d.ts

@@ -0,0 +1,17 @@
+import { Severity } from './types';
+export declare const FONT_FAMILY = "var(--font-family-base, 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif)";
+export declare const MONO_FONT_FAMILY = "var(--font-family-monospaced, 'SF Mono', 'JetBrains Mono', ui-monospace, Menlo, Monaco, 'Courier New', monospace)";
+export type SectionTone = 'subject' | 'where' | 'assert' | 'message' | 'suggest';
+export declare const SECTION_TONES: Record<SectionTone, {
+    fg: string;
+    line: string;
+    soft: string;
+}>;
+export declare const SUCCESS_COLORS: {
+    bg: string;
+    fg: string;
+};
+export declare const SEVERITY_COLORS: Record<Severity, {
+    bg: string;
+    fg: string;
+}>;

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+export type Severity = 'error' | 'warn' | 'off';
+export type CasingStyle = 'camelCase' | 'kebab-case' | 'snake_case' | 'PascalCase' | 'MACRO_CASE' | 'COBOL-CASE' | 'flatcase';
+export interface SubjectObject {
+    type: string;
+    property?: string | string[] | null;
+    filterInParentKeys?: string[];
+    filterOutParentKeys?: string[];
+    matchParentKeys?: string;
+}
+export interface AssertionObject {
+    casing?: CasingStyle;
+    const?: string;
+    contains?: string[];
+    defined?: boolean;
+    disallowed?: string[];
+    enum?: string[];
+    maxLength?: number;
+    minLength?: number;
+    mutuallyExclusive?: string[];
+    mutuallyRequired?: string[];
+    nonEmpty?: boolean;
+    notPattern?: string;
+    pattern?: string;
+    ref?: boolean | string;
+    required?: string[];
+    requireAny?: string[];
+    schema?: Record<string, unknown> | boolean;
+    sortOrder?: 'asc' | 'desc' | {
+        direction: 'asc' | 'desc';
+        property?: string;
+    };
+}
+export type AssertionKey = keyof AssertionObject;
+export interface WhereObject {
+    subject: SubjectObject;
+    assertions: AssertionObject;
+}
+export interface ConfigurableRule {
+    subject: SubjectObject;
+    assertions: AssertionObject;
+    where?: WhereObject[];
+    message?: string;
+    suggest?: string[];
+    reference?: string;
+    severity?: Severity;
+}
+export interface NamedRule {
+    name: string;
+    rule: ConfigurableRule;
+}
+export interface MatchedNode {
+    ruleIndex: number;
+    pointer: string;
+    nodeType: string;
+    key: string;
+    propertyPointers: string[];
+}
+export interface ProblemInfo {
+    ruleIndex: number;
+    ruleId: string;
+    severity: 'error' | 'warn';
+    message: string;
+    suggest: string[];
+    pointer: string;
+    reportOnKey: boolean;
+    line?: number;
+    col?: number;
+}
+export interface EvaluationResult {
+    matches: MatchedNode[];
+    problems: ProblemInfo[];
+    ruleErrors: string[];
+    specError?: string;
+}
+export interface HostAdapters {
+    copyToClipboard?: (text: string) => Promise<void>;
+    pickSpecFile?: () => Promise<{
+        name: string;
+        content: string;
+    } | undefined>;
+    downloadFile?: (fileName: string, content: string) => Promise<void> | void;
+}

package/dist/validation.d.ts

@@ -0,0 +1,4 @@
+import { ConfigurableRule, SubjectObject } from './types';
+export type RuleErrors = Record<string, string>;
+export declare function hasSubjectProperty(subject: SubjectObject): boolean;
+export declare function validateRule(name: string, rule: ConfigurableRule): RuleErrors;

package/dist/yaml/parse.d.ts

@@ -0,0 +1,7 @@
+import { NamedRule } from '../types';
+export interface ImportResult {
+    rules: NamedRule[];
+    skipped: string[];
+    error?: string;
+}
+export declare function parseImportedRules(text: string): ImportResult;

package/dist/yaml/serialize.d.ts

@@ -0,0 +1,2 @@
+import { NamedRule } from '../types';
+export declare function serializeRules(rules: NamedRule[]): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/config-rules-builder",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Visual builder for Redocly configurable rules (rule/*) with live matching against an OpenAPI document",
   "keywords": [
     "redocly",