flappa-doormal 2.9.0 → 2.10.0

package/AGENTS.md

@@ -42,6 +42,7 @@ src/
     ├── breakpoint-processor.ts # Breakpoint post-processing engine (applyBreakpoints)
     ├── breakpoint-utils.ts     # Breakpoint processing utilities (windowing, excludes, page joins)
     ├── rule-regex.ts           # SplitRule -> compiled regex builder (buildRuleRegex, processPattern)
+    ├── optimize-rules.ts       # Rule optimization logic (merge, dedupe, sort)
     ├── tokens.ts               # Token definitions and expansion logic  
     ├── fuzzy.ts                # Diacritic-insensitive matching utilities
     ├── html.ts                 # HTML utilities (stripHtmlTags)
@@ -69,32 +70,38 @@ src/
    - Deterministic mode reruns segmentation with selected rules converted to `lineStartsWith` and merges recovered `content` back into the provided segments
    - Optional `mode: 'best_effort_then_rerun'` attempts a conservative anchor-based recovery first, then falls back to rerun for unresolved segments
 
-2. **`tokens.ts`** - Template system
+3. **`tokens.ts`** - Template system
    - `TOKEN_PATTERNS` - Map of token names to regex patterns
    - `expandTokensWithCaptures()` - Expands `{{token:name}}` syntax
    - `shouldDefaultToFuzzy()` - Checks if patterns contain fuzzy-default tokens (bab, basmalah, fasl, kitab, naql)
+   - `applyTokenMappings()` - Applies named captures (`{{token:name}}`) to raw templates
+   - `stripTokenMappings()` - Strips named captures (reverts to `{{token}}`)
    - Supports fuzzy transform for diacritic-insensitive matching
    - **Fuzzy-default tokens**: `bab`, `basmalah`, `fasl`, `kitab`, `naql` - auto-enable fuzzy matching unless `fuzzy: false` is set
 
-3. **`match-utils.ts`** - Extracted utilities (for testability)
+4. **`match-utils.ts`** - Extracted utilities (for testability)
    - `extractNamedCaptures()` - Get named groups from regex match
    - `filterByConstraints()` - Apply min/max page filters
    - `anyRuleAllowsId()` - Check if page passes rule constraints
 
-4. **`rule-regex.ts`** - SplitRule → compiled regex builder
+5. **`rule-regex.ts`** - SplitRule → compiled regex builder
    - `buildRuleRegex()` - Compiles rule patterns (`lineStartsWith`, `lineStartsAfter`, `lineEndsWith`, `template`, `regex`)
    - `processPattern()` - Token expansion + auto-escaping + optional fuzzy application
    - `extractNamedCaptureNames()` - Extract `(?<name>...)` groups from raw regex patterns
 
-5. **`pattern-validator.ts`** - Rule validation utilities
+6. **`optimize-rules.ts`** - Rule management logic
+   - `optimizeRules()` - Merges compatible rules, deduplicates patterns, and sorts by specificity (longest patterns first)
+
+7. **`pattern-validator.ts`** - Rule validation utilities
    - `validateRules()` - Detects typos in patterns (missing `{{}}`, unknown tokens, duplicates)
+   - `formatValidationReport()` - Formats validation issues into human-readable strings
    - Returns parallel array structure for easy error tracking
 
-6. **`breakpoint-processor.ts`** - Breakpoint post-processing engine
+8. **`breakpoint-processor.ts`** - Breakpoint post-processing engine
    - `applyBreakpoints()` - Splits oversized structural segments using breakpoint patterns + windowing
    - Applies `pageJoiner` normalization to breakpoint-created segments
 
-7. **`breakpoint-utils.ts`** - Breakpoint processing utilities
+9. **`breakpoint-utils.ts`** - Breakpoint processing utilities
    - `normalizeBreakpoint()` - Convert string to BreakpointRule object
    - `isPageExcluded()` - Check if page is in exclude list
    - `isInBreakpointRange()` - Validate page against min/max/exclude constraints
@@ -111,16 +118,17 @@ src/
    - `findNextPagePosition()` - Find next page content position
    - `findPatternBreakPosition()` - Find pattern match by preference
 
-7. **`types.ts`** - Type definitions
+10. **`types.ts`** - Type definitions
    - `Logger` interface - Optional logging for debugging
    - `SegmentationOptions` - Options with `logger` property
    - `pageJoiner` - Controls how page boundaries are represented in output (`space` default)
+   - `PATTERN_TYPE_KEYS` - Runtime array of all pattern types (for UI building)
    - Verbosity levels: `trace`, `debug`, `info`, `warn`, `error`
 
-8. **`fuzzy.ts`** - Arabic text normalization
+11. **`fuzzy.ts`** - Arabic text normalization
    - `makeDiacriticInsensitive()` - Generate regex that ignores diacritics
 
-9. **`pattern-detection.ts`** - Token auto-detection (NEW)
+12. **`pattern-detection.ts`** - Token auto-detection (NEW)
    - `detectTokenPatterns()` - Detect tokens in text with positions
    - `generateTemplateFromText()` - Convert text to template string
    - `suggestPatternConfig()` - Suggest rule configuration
@@ -402,6 +410,8 @@ bunx biome lint .
    - `src/segmentation/replace.ts` (preprocessing parity)
    - `src/recovery.ts` (recovery implementation)
 
+10. **Prefer library utilities for UI tasks**: Instead of re-implementing rule merging, validation, or token mapping in client code, use `optimizeRules`, `validateRules`/`formatValidationReport`, and `applyTokenMappings`. They handle edge cases (like duplicate patterns, regex safety, or diacritic handling) that ad-hoc implementations might miss.
+
 ### Process Template (Multi-agent design review, TDD-first)
 
 If you want to repeat the “write a plan → get multiple AI critiques → synthesize → update plan → implement TDD-first” workflow, use:

package/README.md

@@ -158,6 +158,23 @@ const rules = [{
 | `template` | Depends | Custom pattern with full control |
 | `regex` | Depends | Raw regex for complex cases |
 
+#### Building UIs with Pattern Type Keys
+
+The library exports `PATTERN_TYPE_KEYS` (a const array) and `PatternTypeKey` (a type) for building UIs that let users select pattern types:
+
+```typescript
+import { PATTERN_TYPE_KEYS, type PatternTypeKey } from 'flappa-doormal';
+
+// PATTERN_TYPE_KEYS = ['lineStartsWith', 'lineStartsAfter', 'lineEndsWith', 'template', 'regex']
+
+// Build a dropdown/select
+PATTERN_TYPE_KEYS.map(key => <option value={key}>{key}</option>)
+
+// Type-safe validation
+const isPatternKey = (k: string): k is PatternTypeKey =>
+  (PATTERN_TYPE_KEYS as readonly string[]).includes(k);
+```
+
 ### 4.1 Page-start Guard (avoid page-wrap false positives)
 
 When matching at line starts (e.g., `{{naql}}`), a new page can begin with a marker that is actually a **continuation** of the previous page (page wrap), not a true new segment.
@@ -495,8 +512,34 @@ const segments = segmentPages(pages, { rules });
 // ]
 ```
 
-## Rule Validation
+## Rule Optimization
 
+Use `optimizeRules()` to automatically merge compatible rules, remove duplicate patterns, and sort rules by specificity (longest patterns first):
+
+```typescript
+import { optimizeRules } from 'flappa-doormal';
+
+const rules = [
+  // These will be merged because meta/fuzzy options match
+  { lineStartsWith: ['{{kitab}}'], fuzzy: true, meta: { type: 'header' } },
+  { lineStartsWith: ['{{bab}}'], fuzzy: true, meta: { type: 'header' } },
+  
+  // This will be kept separate
+  { lineStartsAfter: ['{{numbered}}'], meta: { type: 'entry' } },
+];
+
+const { rules: optimized, mergedCount } = optimizeRules(rules);
+
+// Result:
+// optimized[0] = { 
+//   lineStartsWith: ['{{kitab}}', '{{bab}}'], 
+//   fuzzy: true, 
+//   meta: { type: 'header' } 
+// }
+// optimized[1] = { lineStartsAfter: ['{{numbered}}'], ... }
+```
+
+## Rule Validation
 
 Use `validateRules()` to detect common mistakes in rule patterns before running segmentation:
 
@@ -512,6 +555,16 @@ const issues = validateRules([
 // issues[0]?.lineStartsAfter?.[0]?.type === 'missing_braces'
 // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'
 // issues[2]?.lineStartsAfter?.[0]?.type === 'missing_braces'
+
+// To get a simple list of error strings for UI display:
+import { formatValidationReport } from 'flappa-doormal';
+
+const errors = formatValidationReport(issues);
+// [
+//   'Rule 1, lineStartsAfter: Missing {{}} around token "raqms:num"',
+//   'Rule 2, lineStartsWith: Unknown token "{{unknown}}"',
+//   ...
+// ]
 ```
 
 **Checks performed:**
@@ -519,6 +572,25 @@ const issues = validateRules([
 - **Unknown tokens**: Flags tokens inside `{{}}` that don't exist (e.g., `{{nonexistent}}`)
 - **Duplicates**: Finds duplicate patterns within the same rule
 
+## Token Mapping Utilities
+
+When building UIs for rule editing, it's often useful to separate the *token pattern* (e.g., `{{raqms}}`) from the *capture name* (e.g., `{{raqms:hadithNum}}`).
+
+```typescript
+import { applyTokenMappings, stripTokenMappings } from 'flappa-doormal';
+
+// 1. Apply user-defined mappings to a raw template
+const template = '{{raqms}} {{dash}}';
+const mappings = [{ token: 'raqms', name: 'num' }];
+
+const result = applyTokenMappings(template, mappings);
+// result = '{{raqms:num}} {{dash}}'
+
+// 2. Strip captures to get back to the canonical pattern
+const raw = stripTokenMappings(result);
+// raw = '{{raqms}} {{dash}}'
+```
+
 ## Prompting LLMs / Agents to Generate Rules (Shamela books)
 
 ### Pre-analysis (no LLM required): generate “hints” from the book

package/dist/index.d.mts

@@ -218,6 +218,28 @@ type LineEndsWithPattern = {
  * - `lineEndsWith` - Match line endings
  */
 type PatternType = RegexPattern | TemplatePattern | LineStartsWithPattern | LineStartsAfterPattern | LineEndsWithPattern;
+/**
+ * Pattern type key names for split rules.
+ *
+ * Use this array to dynamically iterate over pattern types in UIs,
+ * or use the `PatternTypeKey` type for type-safe string unions.
+ *
+ * @example
+ * // Build a dropdown/select in UI
+ * PATTERN_TYPE_KEYS.map(key => <option value={key}>{key}</option>)
+ *
+ * @example
+ * // Type-safe pattern key validation
+ * const validateKey = (k: string): k is PatternTypeKey =>
+ *   (PATTERN_TYPE_KEYS as readonly string[]).includes(k);
+ */
+declare const PATTERN_TYPE_KEYS: readonly ["lineStartsWith", "lineStartsAfter", "lineEndsWith", "template", "regex"];
+/**
+ * String union of pattern type key names.
+ *
+ * Derived from `PATTERN_TYPE_KEYS` to stay in sync automatically.
+ */
+type PatternTypeKey = (typeof PATTERN_TYPE_KEYS)[number];
 /**
  * Configuration for how and where to split content when a pattern matches.
  *
@@ -745,6 +767,46 @@ type Segment = {
   meta?: Record<string, unknown>;
 };
 //#endregion
+//#region src/segmentation/optimize-rules.d.ts
+/**
+ * Result from optimizing rules.
+ */
+type OptimizeResult = {
+  /** Optimized rules (merged and sorted by specificity) */
+  rules: SplitRule[];
+  /** Number of rules that were merged into existing rules */
+  mergedCount: number;
+};
+/**
+ * Optimize split rules by merging compatible rules and sorting by specificity.
+ *
+ * This function:
+ * 1. **Merges compatible rules**: Rules with the same pattern type and identical
+ *    options (meta, fuzzy, min/max, etc.) have their pattern arrays combined
+ * 2. **Deduplicates patterns**: Removes duplicate patterns within each rule
+ * 3. **Sorts by specificity**: Rules with longer patterns come first
+ *
+ * Only array-based pattern types (`lineStartsWith`, `lineStartsAfter`, `lineEndsWith`)
+ * can be merged. `template` and `regex` rules are kept separate.
+ *
+ * @param rules - Array of split rules to optimize
+ * @returns Optimized rules and count of merged rules
+ *
+ * @example
+ * import { optimizeRules } from 'flappa-doormal';
+ *
+ * const { rules, mergedCount } = optimizeRules([
+ *   { lineStartsWith: ['{{kitab}}'], fuzzy: true, meta: { type: 'header' } },
+ *   { lineStartsWith: ['{{bab}}'], fuzzy: true, meta: { type: 'header' } },
+ *   { lineStartsAfter: ['{{numbered}}'], meta: { type: 'entry' } },
+ * ]);
+ *
+ * // rules[0] = { lineStartsWith: ['{{kitab}}', '{{bab}}'], fuzzy: true, meta: { type: 'header' } }
+ * // rules[1] = { lineStartsAfter: ['{{numbered}}'], meta: { type: 'entry' } }
+ * // mergedCount = 1
+ */
+declare const optimizeRules: (rules: SplitRule[]) => OptimizeResult;
+//#endregion
 //#region src/segmentation/pattern-validator.d.ts
 /**
  * Types of validation issues that can be detected.
@@ -757,6 +819,10 @@ type ValidationIssue = {
   type: ValidationIssueType;
   message: string;
   suggestion?: string;
+  /** The token name involved in the issue (for unknown_token / missing_braces) */
+  token?: string;
+  /** The specific pattern involved (for duplicate) */
+  pattern?: string;
 };
 /**
  * Validation result for a single rule, with issues keyed by pattern type.
@@ -788,6 +854,20 @@ type RuleValidationResult = {
  * // issues[1]?.lineStartsWith?.[0]?.type === 'unknown_token'
  */
 declare const validateRules: (rules: SplitRule[]) => (RuleValidationResult | undefined)[];
+/**
+ * Formats a validation result array into a list of human-readable error messages.
+ *
+ * Useful for displaying validation errors in UIs.
+ *
+ * @param results - The result array from `validateRules()`
+ * @returns Array of formatted error strings
+ *
+ * @example
+ * const issues = validateRules(rules);
+ * const errors = formatValidationReport(issues);
+ * // ["Rule 1, lineStartsWith: Missing {{}} around token..."]
+ */
+declare const formatValidationReport: (results: (RuleValidationResult | undefined)[]) => string[];
 //#endregion
 //#region src/segmentation/replace.d.ts
 /**
@@ -1127,6 +1207,63 @@ declare const getAvailableTokens: () => string[];
  * getTokenPattern('unknown') // → undefined
  */
 declare const getTokenPattern: (tokenName: string) => string | undefined;
+/**
+ * Checks if a pattern (or array of patterns) contains tokens that should
+ * default to fuzzy matching.
+ *
+ * Fuzzy-default tokens are: bab, basmalah, fasl, kitab, naql
+ *
+ * @param patterns - Single pattern string or array of pattern strings
+ * @returns `true` if any pattern contains a fuzzy-default token
+ *
+ * @example
+ * shouldDefaultToFuzzy('{{bab}} الإيمان')     // true
+ * shouldDefaultToFuzzy('{{raqms}} {{dash}}')  // false
+ * shouldDefaultToFuzzy(['{{kitab}}', '{{raqms}}']) // true
+ */
+declare const shouldDefaultToFuzzy: (patterns: string | string[]) => boolean;
+/**
+ * Structure for mapping a token to a capture name.
+ */
+type TokenMapping = {
+  token: string;
+  name: string;
+};
+/**
+ * Apply token mappings to a template string.
+ *
+ * Transforms `{{token}}` into `{{token:name}}` based on the provided mappings.
+ * Useful for applying user-configured capture names to a raw template.
+ *
+ * - Only affects exact matches of `{{token}}`.
+ * - Does NOT affect tokens that already have a capture name (e.g. `{{token:existing}}`).
+ * - Does NOT affect capture-only tokens (e.g. `{{:name}}`).
+ *
+ * @param template - The template string to transform
+ * @param mappings - Array of mappings from token name to capture name
+ * @returns Transformed template string with captures applied
+ *
+ * @example
+ * applyTokenMappings('{{raqms}} {{dash}}', [{ token: 'raqms', name: 'num' }])
+ * // → '{{raqms:num}} {{dash}}'
+ */
+declare const applyTokenMappings: (template: string, mappings: TokenMapping[]) => string;
+/**
+ * Strip token mappings from a template string.
+ *
+ * Transforms `{{token:name}}` back into `{{token}}`.
+ * Also transforms `{{:name}}` patterns (capture-only) into `{{}}` (which is invalid/empty).
+ *
+ * Useful for normalizing templates for storage or comparison.
+ *
+ * @param template - The template string to strip
+ * @returns Template string with capture names removed
+ *
+ * @example
+ * stripTokenMappings('{{raqms:num}} {{dash}}')
+ * // → '{{raqms}} {{dash}}'
+ */
+declare const stripTokenMappings: (template: string) => string;
 //#endregion
 //#region src/analysis/line-starts.d.ts
 type LineStartAnalysisOptions = {
@@ -1325,5 +1462,5 @@ declare function recoverMistakenMarkersForRuns(runs: MarkerRecoveryRun[], opts?:
   segments: Segment[];
 };
 //#endregion
-export { type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type DetectedPattern, type ExpandResult, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type MarkerRecoveryReport, type MarkerRecoveryRun, type MarkerRecoverySelector, type Page, type PageRange, type RepeatingSequenceExample, type RepeatingSequenceOptions, type RepeatingSequencePattern, type ReplaceRule, type RuleValidationResult, type Segment, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, type ValidationIssue, type ValidationIssueType, analyzeCommonLineStarts, analyzeRepeatingSequences, analyzeTextForRule, applyReplacements, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, recoverMistakenLineStartsAfterMarkers, recoverMistakenMarkersForRuns, segmentPages, suggestPatternConfig, templateToRegex, validateRules };
+export { type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type DetectedPattern, type ExpandResult, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type MarkerRecoveryReport, type MarkerRecoveryRun, type MarkerRecoverySelector, type OptimizeResult, PATTERN_TYPE_KEYS, type Page, type PageRange, type PatternTypeKey, type RepeatingSequenceExample, type RepeatingSequenceOptions, type RepeatingSequencePattern, type ReplaceRule, type RuleValidationResult, type Segment, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, type TokenMapping, type ValidationIssue, type ValidationIssueType, analyzeCommonLineStarts, analyzeRepeatingSequences, analyzeTextForRule, applyReplacements, applyTokenMappings, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, formatValidationReport, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, optimizeRules, recoverMistakenLineStartsAfterMarkers, recoverMistakenMarkersForRuns, segmentPages, shouldDefaultToFuzzy, stripTokenMappings, suggestPatternConfig, templateToRegex, validateRules };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/segmentation/fuzzy.ts","../src/segmentation/types.ts","../src/segmentation/pattern-validator.ts","../src/segmentation/replace.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/recovery.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/segmentation/fuzzy.ts","../src/segmentation/types.ts","../src/segmentation/optimize-rules.ts","../src/segmentation/pattern-validator.ts","../src/segmentation/replace.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/analysis/line-starts.ts","../src/analysis/repeating-sequences.ts","../src/detection.ts","../src/recovery.ts"],"sourcesContent":[],"mappings":"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"}