design_source_types.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/design_ir.hpp>
 
#include <cstddef>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace pulp::view {
 
struct SnapshotDynamicApiScan {
    std::vector<std::string> tokens;
 
    bool has_dynamic_apis() const {
        return !tokens.empty();
    }
};
 
enum class DesignMdSeverity { info, warning, error };
 
struct DesignMdDiagnostic {
    DesignMdSeverity severity = DesignMdSeverity::info;
    std::string code; // e.g. "broken-ref", "duplicate-section"
    std::string path; // dotted token path or section name
    int line = 0;     // 1-based; 0 = unknown
    int column = 0;   // 1-based; 0 = unknown
    std::string message;
};
 
struct DesignMdOmittedSection {
    std::string section;
    std::string reason;
};
 
struct DesignMdParseResult {
    DesignIR ir;
    std::vector<DesignMdDiagnostic> diagnostics;
    // Sections seen in the body, in the order they appeared. Used by the
    // section-order lint rule.
    std::vector<std::string> sections;
    bool had_frontmatter = false;
    // Names of color tokens (the part after "colors.") that were
    // dereferenced during parse. `resolve_references` rewrites
    // `{colors.X}` to the resolved hex value in-place, which would
    // otherwise hide the reference from `lint_designmd`'s
    // orphaned-tokens rule. The rule consumes this set directly
    // instead of re-scanning post-resolution strings.
    std::vector<std::string> referenced_color_tokens;
    // DESIGN.md 0.4 `omitted` declarations. These are metadata rather than
    // design tokens; lint uses them to suppress intentional missing-section
    // findings and to report unknown or redundant declarations.
    std::vector<DesignMdOmittedSection> omitted_sections;
};
 
struct DesignMdTokenDiff {
    std::vector<std::string> added;    // tokens present in `after` only
    std::vector<std::string> removed;  // tokens present in `before` only
    std::vector<std::string> modified; // tokens whose value changed
};
 
struct DesignMdDiffResult {
    DesignMdTokenDiff colors;
    DesignMdTokenDiff dimensions;
    DesignMdTokenDiff strings;
    // True if the `after` file has more error- or warning-severity
    // diagnostics than `before` (matches @google/design.md's diff
    // regression semantic).
    bool regression = false;
};

struct ClaudeBundleAsset {
    std::string uuid;          
    std::string mime;          
    std::vector<uint8_t> data; 
};

struct ClaudeBundleFontBinding {
    std::string family;
    std::string runtime_family;
    size_t asset_index = 0;
    std::string weight;
    std::string style;
    std::string unicode_range;
};

struct ClaudeBundleMaterializedBinding {
    std::string id;
    std::string kind; 
    std::string payload_json;
};

struct ClaudeBundle {
    std::vector<ClaudeBundleAsset> assets;  
    std::vector<size_t> javascript_indices; 
    std::vector<ClaudeBundleFontBinding> font_bindings; 
    std::vector<ClaudeBundleMaterializedBinding> materialized_bindings;
    std::uint32_t materialized_schema_version = 1;
    std::string template_html; 
};
 
struct MaterializedDocumentCacheStats {
    std::uint64_t verifies = 0; 
    std::uint64_t hits = 0;     
    std::uint64_t rejected = 0; 
    std::uint64_t waits = 0;    
    std::size_t entries = 0;
    std::size_t bytes = 0; 
};

struct ClaudeRuntimeOptions {
    size_t max_total_js_bytes = 6 * 1024 * 1024;

    std::optional<int> engine_override; // pulp::view::JsEngineType opaque to header

    std::string* error_out = nullptr;

    int runtime_snapshot_viewport_width = 0;
    int runtime_snapshot_viewport_height = 0;
};
 
using ClaudeClassNameRules = std::map<std::string, std::map<std::string, std::string>>;
 
} // namespace pulp::view