@myrmidon/gve-snapshot-rendition 2.0.4 → 2.0.6

package/dist/src/adapter/adapter-models.d.ts

@@ -1,171 +0,0 @@
-/**
- * Models and types for the feature adapter system.
- */
-import { Feature } from "../models.js";
-/**
- * Comparison operator for feature matching.
- */
-export declare enum ComparisonOperator {
-    /** Equals (string) */
-    EQUALS = "=",
-    /** Not equals (string) */
-    NOT_EQUALS = "!=",
-    /** Starts with */
-    STARTS_WITH = "^=",
-    /** Ends with */
-    ENDS_WITH = "$=",
-    /** Contains */
-    CONTAINS = "*=",
-    /** Matches wildcards (? and *) */
-    MATCHES_WILDCARDS = "?=",
-    /** Matches regular expression */
-    MATCHES_REGEX = "~",
-    /** Numeric equals */
-    NUMERIC_EQUALS = "==",
-    /** Numeric not equals */
-    NUMERIC_NOT_EQUALS = "<>",
-    /** Numeric greater than */
-    NUMERIC_GT = ">",
-    /** Numeric less than */
-    NUMERIC_LT = "<",
-    /** Numeric greater than or equal */
-    NUMERIC_GTE = ">=",
-    /** Numeric less than or equal */
-    NUMERIC_LTE = "<="
-}
-/**
- * Logical operator for combining clauses.
- */
-export declare enum LogicalOperator {
-    AND = "AND",
-    OR = "OR",
-    AND_NOT = "AND NOT",
-    OR_NOT = "OR NOT"
-}
-/**
- * Token type for DSL parsing.
- */
-export declare enum TokenType {
-    /** Feature name */
-    NAME = 0,
-    /** Comparison operator */
-    OPERATOR = 1,
-    /** Value (quoted or unquoted) */
-    VALUE = 2,
-    /** Logical operator (AND, OR, AND NOT, OR NOT) */
-    LOGICAL = 3,
-    /** Left parenthesis */
-    LPAREN = 4,
-    /** Right parenthesis */
-    RPAREN = 5,
-    /** Left square bracket for group capture */
-    LBRACKET = 6,
-    /** Right square bracket for group capture */
-    RBRACKET = 7,
-    /** Colon (used in named groups) */
-    COLON = 8,
-    /** End of input */
-    EOF = 9
-}
-/**
- * Token from DSL parsing.
- */
-export interface Token {
-    type: TokenType;
-    value: string;
-    position: number;
-}
-/**
- * A single clause in a pattern (e.g., "name=value").
- */
-export interface Clause {
-    /** Feature name to match */
-    name: string;
-    /** Comparison operator (optional if just matching by name) */
-    operator?: ComparisonOperator;
-    /** Value to compare against (optional if just matching by name) */
-    value?: string;
-    /** Whether this clause should be captured as a group */
-    capture?: boolean;
-    /** Group name (if named capture), or undefined for numbered capture */
-    groupName?: string;
-}
-/**
- * Pattern expression node (for AST representation).
- */
-export interface PatternExpression {
-    type: "clause" | "logical";
-}
-/**
- * Clause expression node.
- */
-export interface ClauseExpression extends PatternExpression {
-    type: "clause";
-    clause: Clause;
-}
-/**
- * Logical expression node (binary operation).
- */
-export interface LogicalExpression extends PatternExpression {
-    type: "logical";
-    operator: LogicalOperator;
-    left: PatternExpression;
-    right: PatternExpression;
-}
-/**
- * Result of matching a pattern against features.
- */
-export interface MatchResult {
-    /** Whether the pattern matched */
-    matched: boolean;
-    /** Captured groups (keyed by group name or number as string) */
-    captures: Map<string, CapturedGroup>;
-    /** Features that were matched */
-    matchedFeatures: Feature[];
-}
-/**
- * A captured group from pattern matching.
- */
-export interface CapturedGroup {
-    name: string;
-    value: string;
-}
-/**
- * Mode for feature processing.
- */
-export declare enum ProcessingMode {
-    /** Add features without removing matched ones */
-    ADD = "add",
-    /** Replace: remove matched features, then add new ones */
-    REPLACE = "replace"
-}
-/**
- * A single adapter operation configuration.
- */
-export interface AdapterOperation {
-    /** Pattern DSL string to match features */
-    pattern: string;
-    /** Features to add (with format "name=value", can include placeholders) */
-    features: string[];
-    /** Processing mode (default: add) */
-    mode?: ProcessingMode;
-}
-/**
- * Configuration for the feature adapter.
- */
-export interface FeatureAdapterSettings {
-    /** List of adapter operations to apply in order */
-    operations: AdapterOperation[];
-}
-/**
- * Error thrown during DSL parsing or pattern matching.
- */
-export declare class AdapterError extends Error {
-    position?: number | undefined;
-    context?: string | undefined;
-    constructor(message: string, position?: number | undefined, context?: string | undefined);
-    /**
-     * Format error message with context.
-     */
-    toString(): string;
-}

package/dist/src/adapter/data-feature-adapter.d.ts

@@ -1,30 +0,0 @@
-/**
- * Data feature adapter for applying feature transformations to CharChainResult data.
- */
-import { CharChainResult } from "../models";
-import { FeatureAdapterSettings } from "./adapter-models";
-/**
- * Adapter service that applies feature transformations to CharChainResult data.
- * This service creates a copy of the data and adapts all features except those
- * belonging to operation metadata.
- */
-export declare class DataFeatureAdapter {
-    private featureAdapter;
-    constructor(settings: FeatureAdapterSettings);
-    /**
-     * Adapt all features in the CharChainResult data.
-     * Returns a new copy of the data with adapted features.
-     *
-     * Features adapted:
-     * - globalFeatures[tag][i] (global features per version)
-     * - nodes[i].features[tag][j] (per-node, per-version features)
-     *
-     * Features NOT adapted:
-     * - steps[i].operation.features (operation metadata)
-     */
-    adaptData(data: CharChainResult): CharChainResult;
-    /**
-     * Deep copy the CharChainResult data structure.
-     */
-    private deepCopyData;
-}

package/dist/src/adapter/feature-adapter.d.ts

@@ -1,34 +0,0 @@
-/**
- * Feature adapter service for transforming feature sets.
- */
-import { FeatureAdapterSettings } from "./adapter-models";
-import { Feature } from "../models";
-/**
- * Service for adapting features based on configured operations.
- */
-export declare class FeatureAdapter {
-    private settings;
-    private compiledPatterns;
-    private matcher;
-    constructor(settings: FeatureAdapterSettings);
-    /**
-     * Adapt a feature array by applying all configured operations.
-     */
-    adapt(features: Feature[]): Feature[];
-    /**
-     * Apply a single operation to a feature array.
-     */
-    private applyOperation;
-    /**
-     * Create features from feature specifications, resolving placeholders.
-     */
-    private createFeatures;
-    /**
-     * Resolve placeholders in a string (e.g., $1.value, $color.name).
-     */
-    private resolvePlaceholders;
-    /**
-     * Pre-compile all patterns to detect errors early.
-     */
-    private compilePatterns;
-}

package/dist/src/adapter/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Feature adapter module - public API.
- */
-export { FeatureAdapter } from "./feature-adapter.js";
-export { DataFeatureAdapter } from "./data-feature-adapter.js";
-export type { FeatureAdapterSettings, AdapterOperation, ProcessingMode, ComparisonOperator, LogicalOperator, AdapterError, } from "./adapter-models.js";

package/dist/src/adapter/matcher.d.ts

@@ -1,38 +0,0 @@
-/**
- * Feature matching engine for the adapter.
- */
-import { PatternExpression, MatchResult } from "./adapter-models";
-import { Feature } from "../models";
-/**
- * Matches features against a pattern expression.
- */
-export declare class FeatureMatcher {
-    /**
-     * Match features against a parsed pattern expression.
-     */
-    match(features: Feature[], expression: PatternExpression): MatchResult;
-    /**
-     * Evaluate a pattern expression against features.
-     */
-    private evaluateExpression;
-    /**
-     * Evaluate a clause against features.
-     */
-    private evaluateClause;
-    /**
-     * Check if a single feature matches a clause.
-     */
-    private matchFeature;
-    /**
-     * Compare values using the specified operator.
-     */
-    private compareValues;
-    /**
-     * Match a value against a wildcard pattern (? and *).
-     */
-    private matchWildcard;
-    /**
-     * Compare numeric values.
-     */
-    private compareNumeric;
-}

package/dist/src/adapter/parser.d.ts

@@ -1,58 +0,0 @@
-/**
- * Parser for the feature adapter DSL.
- * Implements recursive descent parsing with operator precedence:
- * 1. NOT (highest)
- * 2. AND
- * 3. OR (lowest)
- */
-import { PatternExpression } from "./adapter-models";
-/**
- * Parser for DSL patterns.
- */
-export declare class Parser {
-    private input;
-    private tokens;
-    private position;
-    private current;
-    private groupCounter;
-    constructor(input: string);
-    /**
-     * Parse the pattern and return the AST.
-     */
-    parse(): PatternExpression;
-    /**
-     * Parse OR expression (lowest precedence).
-     * or_expr := and_expr (OR and_expr | OR NOT and_expr)*
-     */
-    private parseOrExpression;
-    /**
-     * Parse AND expression (middle precedence).
-     * and_expr := primary (AND primary | AND NOT primary)*
-     */
-    private parseAndExpression;
-    /**
-     * Parse primary expression (clause or grouped expression).
-     * primary := clause | '(' or_expr ')' | '[' clause ']' | '[' NAME ':' clause ']'
-     */
-    private parsePrimary;
-    /**
-     * Parse a captured clause: [name:clause] or [clause]
-     */
-    private parseCapturedClause;
-    /**
-     * Parse a clause: name [operator value]
-     */
-    private parseClause;
-    /**
-     * Advance to the next token.
-     */
-    private advance;
-    /**
-     * Peek at the next token without consuming it.
-     */
-    private peek;
-    /**
-     * Get context around a position for error messages.
-     */
-    private getContext;
-}

package/dist/src/adapter/tokenizer.d.ts

@@ -1,55 +0,0 @@
-/**
- * Tokenizer for the feature adapter DSL.
- */
-import { Token } from "./adapter-models";
-/**
- * Tokenizes a DSL pattern string into tokens.
- */
-export declare class Tokenizer {
-    private input;
-    private position;
-    private current;
-    private expectValue;
-    constructor(input: string);
-    /**
-     * Tokenize the entire input.
-     */
-    tokenize(): Token[];
-    /**
-     * Get the next token from input.
-     */
-    private nextToken;
-    /**
-     * Try to read a comparison operator.
-     */
-    private tryReadOperator;
-    /**
-     * Read a quoted string (handles escape sequences).
-     */
-    private readQuotedString;
-    /**
-     * Read a word (name or keyword).
-     */
-    private readWord;
-    /**
-     * Read an unquoted value (after an operator).
-     * Values can include special characters like *, ?, ^, $, etc.
-     */
-    private readUnquotedValue;
-    /**
-     * Peek at the next word without consuming it.
-     */
-    private peekWord;
-    /**
-     * Skip whitespace.
-     */
-    private skipWhitespace;
-    /**
-     * Advance to next character.
-     */
-    private advance;
-    /**
-     * Get context around current position for error messages.
-     */
-    private getContext;
-}

package/dist/src/animation/animation-engine.d.ts

@@ -1,105 +0,0 @@
-import { Logger } from "../core/logger";
-import { AnimationFactory, AnimationFunction } from "./animation-factory";
-/**
- * Animation engine that wraps GSAP and provides a consistent API.
- */
-export declare class AnimationEngine {
-    private _gsap;
-    private _logger;
-    private _factory;
-    constructor(gsap: any, logger: Logger);
-    /**
-     * Get the animation factory.
-     */
-    getFactory(): AnimationFactory;
-    /**
-     * Animate an element with an animation function.
-     *
-     * @param element - The target SVG element
-     * @param animation - The animation function to execute
-     * @param rootElement - The root SVG element
-     * @returns Promise that resolves when animation completes
-     */
-    animate(element: SVGElement, animation: AnimationFunction, rootElement: SVGElement): Promise<void>;
-    /**
-     * Fade in multiple elements (used for hilites).
-     *
-     * @param elements - Array of elements to fade in
-     * @param duration - Duration in milliseconds
-     * @returns Promise that resolves when animation completes
-     */
-    fadeIn(elements: SVGElement[], duration: number): Promise<void>;
-    /**
-     * Fade out multiple elements (used for hilites).
-     *
-     * @param elements - Array of elements to fade out
-     * @param duration - Duration in milliseconds
-     * @returns Promise that resolves when animation completes
-     */
-    fadeOut(elements: SVGElement[], duration: number): Promise<void>;
-    /**
-     * Animate pan and zoom transition.
-     *
-     * @param panZoomInstance - The svg-pan-zoom instance
-     * @param newPan - New pan coordinates {x, y}
-     * @param newZoom - New zoom level
-     * @param duration - Duration in milliseconds
-     * @returns Promise that resolves when animation completes
-     */
-    animatePanZoom(panZoomInstance: any, newPan: {
-        x: number;
-        y: number;
-    }, newZoom: number, duration: number): Promise<void>;
-    /**
-     * Animate prolog panning to make an element visible.
-     * This gracefully pans the viewport so there is room to display an element
-     * that would otherwise fall outside the visible area.
-     *
-     * @param panZoomInstance - The svg-pan-zoom instance
-     * @param elementBounds - Bounding rectangle of the element to make visible
-     * @param viewportWidth - Width of the visible viewport
-     * @param viewportHeight - Height of the visible viewport
-     * @param duration - Duration in milliseconds
-     * @returns Promise that resolves when animation completes
-     */
-    animateProlog(panZoomInstance: any, elementBounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, viewportWidth: number, viewportHeight: number, duration: number): Promise<void>;
-    /**
-     * Calculate the pan adjustment needed to make an element visible.
-     * Returns null if the element is already fully visible.
-     *
-     * @param elementBounds - Bounding rectangle of the element in SVG coordinates
-     * @param panZoomInstance - The svg-pan-zoom instance
-     * @param viewportWidth - Width of the visible viewport
-     * @param viewportHeight - Height of the visible viewport
-     * @returns New pan coordinates or null if no adjustment needed
-     */
-    private calculatePrologPan;
-    /**
-     * Check if an element is fully visible in the current viewport.
-     *
-     * @param elementBounds - Bounding rectangle of the element in SVG coordinates
-     * @param panZoomInstance - The svg-pan-zoom instance
-     * @param viewportWidth - Width of the visible viewport
-     * @param viewportHeight - Height of the visible viewport
-     * @returns True if element is fully visible, false otherwise
-     */
-    isElementVisible(elementBounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, panZoomInstance: any, viewportWidth: number, viewportHeight: number): boolean;
-    /**
-     * Kill all active animations.
-     */
-    killAll(): void;
-    /**
-     * Get the GSAP instance.
-     */
-    getGsap(): any;
-}

package/dist/src/animation/animation-factory.d.ts

@@ -1,49 +0,0 @@
-import { Logger } from "../core/logger";
-/**
- * Animation function signature.
- * Receives gsap instance, target element, and root SVG element.
- * Returns a Promise that resolves when animation completes.
- */
-export type AnimationFunction = (gsap: any, targetEl: SVGElement, rootEl: SVGElement) => Promise<void>;
-/**
- * Factory for creating animation functions from code strings.
- * This wraps user-provided GSAP animation code into executable functions.
- */
-export declare class AnimationFactory {
-    private _logger;
-    private _gsap;
-    constructor(gsap: any, logger: Logger);
-    /**
-     * Create an animation function from a code string.
-     *
-     * @param code - The JavaScript code as a string that uses GSAP
-     * @param label - Optional label for debugging
-     * @returns An animation function that returns a Promise
-     */
-    createAnimation(code: string, label?: string): AnimationFunction;
-    /**
-     * Create an animation function from an ID reference.
-     * The ID should exist in the animations catalog.
-     *
-     * @param animationId - The ID of the animation (with or without # prefix)
-     * @param animationsCatalog - The catalog of animations from settings
-     * @param label - Optional label for debugging
-     * @returns An animation function or undefined if not found
-     */
-    createAnimationFromId(animationId: string, animationsCatalog: Record<string, string>, label?: string): AnimationFunction | undefined;
-    /**
-     * Resolve an animation property value to an animation function.
-     * Handles both direct code strings and ID references.
-     *
-     * @param animationValue - Either a code string or an ID reference (starting with #)
-     * @param animationsCatalog - The catalog of animations from settings
-     * @param label - Optional label for debugging
-     * @returns An animation function or undefined
-     */
-    resolveAnimation(animationValue: string | undefined, animationsCatalog: Record<string, string>, label?: string): AnimationFunction | undefined;
-    /**
-     * Create a no-op animation that resolves immediately.
-     * Used when no animation is specified.
-     */
-    createNoOpAnimation(): AnimationFunction;
-}

package/dist/src/core/color-palette.d.ts

@@ -1,39 +0,0 @@
-/**
- * Generate a pastel color palette for version tags with maximum visual distinction.
- * Uses HSL color space to generate evenly distributed, light, pastel colors.
- */
-export declare class ColorPalette {
-    private colors;
-    /**
-     * Generate a pastel color for a given version tag.
-     * The color generation is idempotent - same version tag always generates the same color.
-     * @param versionTag - Version tag (e.g., "v0", "v1", "v2")
-     * @returns Pastel color as hex string (e.g., "#FFE4E1")
-     */
-    getColor(versionTag: string): string;
-    /**
-     * Extract version number from version tag.
-     * @param versionTag - Version tag like "v0", "v1", etc.
-     * @returns Version number
-     */
-    private extractVersionNumber;
-    /**
-     * Generate a pastel color using HSL color space with golden ratio distribution.
-     * This ensures maximum visual distinction between colors.
-     * @param index - Version index number
-     * @returns Hex color string
-     */
-    private generatePastelColor;
-    /**
-     * Convert HSL to hex color.
-     * @param h - Hue (0-360)
-     * @param s - Saturation (0-100)
-     * @param l - Lightness (0-100)
-     * @returns Hex color string
-     */
-    private hslToHex;
-    /**
-     * Clear all cached colors.
-     */
-    clear(): void;
-}