Scryber Configuration File Structure

// set up the configuraion as needed.
IConfigurationRoot config = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();
    
//pass the configuration to the service provider class.
Scryber.ServiceProvider.Init(config);

//set up your app as wanted
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();

//... pass it's configuration to Scryber.

Scryber.ServiceProvider.Init(app.Configuration);

// Internal bootstrap in ServiceProvider
var config = ServiceProvider.GetService<IScryberConfigurationService>();

// Scryber.Imaging/Options/_Extensions.cs
public static ImageFactoryList GetConfiguredFactories(this ImagingOptions options)
{
    ImageDataFactoryOption[] configured = null;
    var standard = GetStandardFactories();
    var list = new ImageFactoryList();
    
    if (null != options && null != options.Factories && options.Factories.Length > 0)
    {
        configured = options.Factories;
        foreach (var configFactory in configured)
        {
            // Lazy-load and cache factory instance
            var instance = configFactory.GetInstance() as IPDFImageDataFactory;
            if (null == instance)
                throw new InvalidCastException(
                    "The configured image data factory entry '" + (configFactory.Name ?? "UNNAMED") +
                    "' does not implement the IImageDataFactory interface");

            // Wrap in custom factory with regex matcher
            var factory = new ImageFactoryCustom(
                new Regex(configFactory.Match), 
                configFactory.Name,
                instance.ShouldCache, 
                instance);

            list.Add(factory);
        }
    }
    
    // Add standard factories AFTER custom factories
    // This allows custom factories to override standard extensions
    list.AddRange(standard);
    
    return list;
}

private static readonly ImageFactoryBase[] Standards = new ImageFactoryBase[]
{
    new ImageFactoryGif(),        // .*\.gif$
    new ImageFactoryPng(),        // .*\.png$
    new ImageFactoryTiff(),       // .*\.(tiff?|tif)$
    new ImageFactoryJpeg(),       // .*\.(jpe?g|jpg)$
    new ImageFactoryPngDataUrl(), // data:image/png
    new ImageFactoryJpegDataUrl(),// data:image/jpeg
    new ImageFactoryGifDataUrl()  // data:image/gif
};

doc.ImageFactories.Insert(0, new MyCustomImageType()); //always checked in order, so go first.

// Scryber.Imaging/Imaging/ImageFactoryBase.cs
public abstract class ImageFactoryBase : IPDFImageDataFactory
{
    public bool ShouldCache { get; }
    public Regex Match { get; }
    public MimeType ImageType { get; }
    public string Name { get; }
    
    public ImageFactoryBase(Regex match, MimeType type, string name, bool shouldCache)
    {
        this.Match = match ?? throw new ArgumentNullException(nameof(match));
        this.ImageType = type ?? MimeType.Empty;
        this.Name = name;
        this.ShouldCache = shouldCache;
    }

    public virtual bool IsMatch(string forPath)
    {
        return this.Match.IsMatch(forPath);
    }
    
    public virtual ImageData LoadImageData(IDocument document, IComponent owner, string path)
    {
        //override to add your own loading logic
    }

    public override async Task<ImageData> LoadImageDataAsync(IDocument document, IComponent owner, string path)
    {
        //Override to add your own async loading logic
    }
    
    protected virtual ImageData DoLoadRawImageData(IDocument document, IComponent owner, byte[] rawData, MimeType type)
    {
        //override to add your own image data conversion.
    }

    protected virtual Task<ImageData> DoLoadImageDataAsync(IDocument document, IComponent owner, string path)
    {
        //override to add your own async image data conversion.
    }
}

public class DatabaseImageFactory : ImageFactoryBase
{
    public DatabaseImageFactory() 
        : base(new Regex(@"^db://"), MimeType.Empty, "DatabaseImages", shouldCache: true)
    {
    }
    
    protected override async Task<ImageData> DoLoadImageDataAsync(IDocument document, IComponent owner, string path)
    {
        // Extract ID from path: db://images/12345
        var id = path.Substring(path.LastIndexOf('/') + 1);
        
        // Load from database
        byte[] imageBytes = await LoadImageFromDatabase(id);
        MimeType type = DetectImageType(imageBytes);
        
        return DoLoadRawImageData(document, owner, imageBytes, type);
    }
    
    protected override ImageData DoLoadRawImageData(IDocument document, IComponent owner, byte[] rawData, MimeType type)
    {
        using (var stream = new MemoryStream(rawData))
        {
            return DoDecodeImageData(stream, document, owner, "db-image");
        }
    }
}

// Scryber.Imaging/Imaging/ImageFactoryList.cs
public bool TryGetMatch(string path, out ImageFactoryBase factory)
{
    // Skip data URLs - they're handled specially
    if (path.StartsWith("data:"))
    {
        // Continue to factory checks
    }
    else if (Uri.IsWellFormedUriString(path, UriKind.RelativeOrAbsolute))
    {
        // Extract local path from URI for matching
        path = new Uri(path).LocalPath;
    }

    // Iterate factories in registration order
    // Custom factories are checked BEFORE standard factories
    foreach (var match in this)
    {
        if (match.IsMatch(path))
        {
            factory = match;
            return true;
        }
    }

    factory = null;
    return false;
}

// Scryber.Drawing/Drawing/FontFactory.cs
private static FamilyReferenceBag _static;   // Embedded Standard Type 1 fonts (Helvetica, Times, Courier, etc.)
private static FamilyReferenceBag _system;   // System-installed fonts (platform-dependent)
private static FamilyReferenceBag _custom;   // User-registered fonts from configuration
private static FamilyReferenceBag _generic;  // Generic family mappings (Sans-Serif → Helvetica)

public static FontDefinition GetFontDefinition(String family, FontStyle style, int weight, bool throwNotFound = true)
{
    FamilyReference fref;
    FontReference fontRef = null;

    // 1. Check custom fonts (user-registered)
    if (_custom.TryGetFamily(family, out fref))
    {
        fontRef = fref.GetFont(style, weight);
    }
    
    // 2. Check system fonts
    if (fontRef == null && _system.TryGetFamily(family, out fref))
    {
        fontRef = fref.GetFont(style, weight);
    }
    
    // 3. Check static fonts (embedded Type 1)
    if (fontRef == null && _static.TryGetFamily(family, out fref))
    {
        fontRef = fref.GetFont(style, weight);
    }
    
    // 4. Check generic family mappings
    if (fontRef == null && _generic.TryGetFamily(family, out fref))
    {
        fontRef = fref.GetFont(style, weight);
    }

    if (fontRef == null)
    {
        if (throwNotFound)
            throw new ArgumentException($"Font '{family}' not found");
        return null;
    }

    // Lazy-load font definition
    if (!fontRef.IsLoaded)
    {
        LoadFontDefinition(fontRef);
    }

    return fontRef.Definition;
}

// Scryber.Drawing/Drawing/FontFactory.cs
private static FamilyReferenceBag UnsafeLoadCustomFonts(FontOptions options)
{
    FamilyReferenceBag custom = new FamilyReferenceBag();

    if (options.Register == null || options.Register.Length == 0) 
        return custom;

    using (var reader = new TypefaceReader())
    {
        foreach (var known in options.Register)
        {
            if (string.IsNullOrEmpty(known.File)) 
                continue;
            
            // Resolve file path (relative to application base)
            var file = new FileInfo(GetFullPath(known.File));
                
            if (!file.Exists) 
                continue;

            // Read OpenType/TrueType font file
            var info = reader.ReadTypeface(file);

            if (null != info && string.IsNullOrEmpty(info.ErrorMessage) && info.FontCount > 0)
            {
                foreach (var font in info.Fonts)
                {
                    // Use configured family name OR font's internal family name
                    var family = known.Family ?? font.FamilyName;
                    
                    // Register font with family, style, and weight
                    custom.AddFont(info, font, family);
                }
            }
        }

        // Scan default directory for additional fonts
        var defaultDir = options.DefaultDirectory;
        if (!string.IsNullOrEmpty(defaultDir))
        {
            UnsafeReadFontsFromDirectory(reader, defaultDir, custom);
        }
    }

    return custom;
}

// Internal font registry structure
private class FamilyReferenceBag : Dictionary<string, FamilyReference>
{
    public FontReference AddFont(ITypefaceInfo info, IFontInfo font, string familyName = null)
    {
        FamilyReference family;

        if (!_families.TryGetValue(familyName ?? font.FamilyName, out family))
        {
            family = new FamilyReference(familyName ?? font.FamilyName);
            _families.Add(familyName ?? family.FamilyName, family);
        }
        
        var reference = family.Add(font, info);
        return reference;
    }
}

private class FamilyReference
{
    public string FamilyName { get; }
    private Dictionary<FontStyleKey, FontReference> _fonts;
    
    public FontReference Add(IFontInfo font, ITypefaceInfo typeface)
    {
        var key = new FontStyleKey(font.FontStyle, font.Weight);
        var reference = new FontReference(font, typeface);
        _fonts[key] = reference;
        return reference;
    }
    
    public FontReference GetFont(FontStyle style, int weight)
    {
        var key = new FontStyleKey(style, weight);
        FontReference exact;
        
        // Try exact match
        if (_fonts.TryGetValue(key, out exact))
            return exact;
        
        // Try font substitution based on style and weight
        return FindClosestFont(style, weight);
    }
}

private static FamilyReferenceBag UnsafeLoadStaticFamilies(FontOptions options)
{
    var bag = new FamilyReferenceBag();
    var assm = typeof(FontFactory).Assembly;
    
    using (var reader = new TypefaceReader())
    {
        // Courier family (4 variants)
        TryReadFontBinary(reader, assm, "Scryber.Text._FontResources.Courier.CourierNew.ttf", out var found);
        bag.AddFont(found, found.Fonts[0], "Courier").Definition = 
            PDFOpenTypeFontDefinition.InitStdType1WinAnsi("Fcour", "Courier", "Courier", "Courier New", 
                false, false, 1228, found.Fonts[0] as IOpenTypeFont);
        
        TryReadFontBinary(reader, assm, "Scryber.Text._FontResources.Courier.CourierNewBold.ttf", out found);
        bag.AddFont(found, found.Fonts[0], "Courier").Definition = 
            PDFOpenTypeFontDefinition.InitStdType1WinAnsi("FcourBo", "Courier-Bold", "Courier", "Courier New", 
                true, false, 1228, found.Fonts[0] as IOpenTypeFont);
        
        // ... Courier-Italic, Courier-BoldItalic
        
        // Helvetica family (4 variants)
        // Times family (4 variants)  
        // Symbol (1 font)
        // ZapfDingbats (1 font)
    }
    
    return bag;
}

// Default registrations in ParsingOptions constructor
Namespaces.Add(new NamespaceMappingOption() 
{ 
    Source = "http://www.scryber.co.uk/schemas/core/release/v1/Scryber.Components.xsd",
    Namespace = "Scryber.Components",
    Assembly = "Scryber.Components, Version=1.0.0.0, Culture=neutral, PublicKeyToken=872cbeb81db952fe"
});

Namespaces.Add(new NamespaceMappingOption() 
{ 
    Source = "http://www.scryber.co.uk/schemas/core/release/v1/Scryber.Data.xsd",
    Namespace = "Scryber.Data",
    Assembly = "Scryber.Components, Version=1.0.0.0, Culture=neutral, PublicKeyToken=872cbeb81db952fe"
});

Namespaces.Add(new NamespaceMappingOption() 
{ 
    Source = "http://www.w3.org/1999/xhtml",
    Namespace = "Scryber.Html.Components",
    Assembly = "Scryber.Components, Version=1.0.0.0, Culture=neutral, PublicKeyToken=872cbeb81db952fe"
});

Namespaces.Add(new NamespaceMappingOption() 
{ 
    Source = "http://www.w3.org/2000/svg",
    Namespace = "Scryber.Svg.Components",
    Assembly = "Scryber.Components, Version=1.0.0.0, Culture=neutral, PublicKeyToken=872cbeb81db952fe"
});

// Scryber.Generation/ParserDefintionFactory.cs
private static Dictionary<string, string> _namespaceMappings;

public static string LookupAssemblyForXmlNamespace(string xmlNamespace)
{
    string assm;
    if (!_namespaceMappings.TryGetValue(xmlNamespace, out assm))
        assm = xmlNamespace; // Fallback: treat XML namespace as assembly namespace
    return assm;
}

private static Dictionary<string, string> InitNamespaceMappings()
{
    var mappings = new Dictionary<string, string>();
    
    var config = ServiceProvider.GetService<IScryberConfigurationService>();
    var options = config.ParsingOptions;
    
    if (options.Namespaces != null)
    {
        foreach (var mapping in options.Namespaces)
        {
            // Format: "Namespace, Assembly"
            string value = mapping.Namespace + ", " + mapping.Assembly;
            mappings[mapping.Source] = value;
        }
    }
    
    return mappings;
}

public static ParserClassDefinition GetClassDefinition(string elementname, string xmlNamespace, 
    bool throwOnNotFound, out bool isremote)
{
    Type found;
    lock (_applicationlock)
    {
        string assemblyQualifiedNamespace = string.Empty;

        if (!string.IsNullOrEmpty(xmlNamespace))
        {
            // Map XML namespace to assembly namespace
            assemblyQualifiedNamespace = LookupAssemblyForXmlNamespace(xmlNamespace);
        }
        else
        {
            // Check unqualified element whitelist
            string unqualNs;
            if (_unqualified.TryGetValue(elementname, out unqualNs))
                assemblyQualifiedNamespace = unqualNs;
        }

        found = UnsafeGetType(elementname, assemblyQualifiedNamespace, throwOnNotFound, out isremote);
    }

    if (null != found)
        return GetClassDefinition(found);
    else
        return null;
}

private static Type UnsafeGetType(string elementname, string assemblyQualifiedNamespace, 
    bool throwOnNotFound, out bool isremote)
{
    AssemblyDefn assmdefn;
    NamespaceDefn nsdefn;
    Type t;

    // Parse "Namespace, Assembly" format
    string assm;
    string ns;
    ExtractAssemblyAndNamespace(assemblyQualifiedNamespace, out assm, out ns);
    
    if (string.IsNullOrEmpty(assm))
    {
        if (throwOnNotFound)
            throw new PDFParserException($"Parser does not have assembly registered for namespace {assemblyQualifiedNamespace}");
        else
            return null;
    }

    // Get or load assembly definition
    if (!_application.TryGetValue(assm, out assmdefn))
    {
        assmdefn = new AssemblyDefn();
        Assembly found = GetAssemblyByName(assm);
        
        if (null == found)
        {
            if (throwOnNotFound)
                throw new PDFParserException($"Parser cannot find assembly with name {assm}");
            else
                return null;
        }
        
        assmdefn.InnerAssembly = found;
        _application[assm] = assmdefn;
    }

    // Get or populate namespace definition
    if (!assmdefn.TryGetValue(ns, out nsdefn))
    {
        nsdefn = new NamespaceDefn();
        PopulateNamespaceFromAssembly(ns, assmdefn, nsdefn);
        assmdefn[ns] = nsdefn;
    }

    // Look up type in namespace
    if (!nsdefn.TryGetValue(elementname, out t))
    {
        // Check remote types (components loaded from external sources)
        string actual;
        if (!nsdefn.RemoteTypes.TryGetValue(elementname, out actual) || 
            !nsdefn.TryGetValue(actual, out t))
        {
            if (throwOnNotFound)
                throw new PDFParserException($"No PDF component declared with name {elementname} in namespace {assemblyQualifiedNamespace}");
            else
                return null;
        }
        else
        {
            isremote = true;
        }
    }
    else
    {
        isremote = false;
    }

    return t;
}

private static void PopulateNamespaceFromAssembly(string ns, AssemblyDefn assmdefn, NamespaceDefn nsdefn)
{
    Type[] all = assmdefn.InnerAssembly.GetTypes();
    
    foreach (Type t in all)
    {
        if (string.Equals(t.Namespace, ns))
        {
            // Check for PDFParsableComponent attribute
            object[] attrs = t.GetCustomAttributes(typeof(PDFParsableComponentAttribute), false);
            
            if (null != attrs && attrs.Length > 0)
            {
                PDFParsableComponentAttribute compattr = (PDFParsableComponentAttribute)attrs[0];
                string name = compattr.ElementName;
                
                if (string.IsNullOrEmpty(name))
                    name = t.Name;

                // Register concrete element
                nsdefn.Add(name, t);

                // Check for remote element variant
                attrs = t.GetCustomAttributes(typeof(PDFRemoteParsableComponentAttribute), false);
                if (null != attrs && attrs.Length > 0)
                {
                    PDFRemoteParsableComponentAttribute remattr = (PDFRemoteParsableComponentAttribute)attrs[0];
                    string remotename = remattr.ElementName;
                    
                    if (string.IsNullOrEmpty(remotename))
                        remotename = t.Name + "-Ref";
                    
                    // Map remote element name to concrete element name
                    nsdefn.RemoteTypes.Add(remotename, name);
                }
            }
        }
    }
}

using Scryber.Generation;
using Scryber.Components;

namespace MyCompany.CustomComponents
{
    [PDFParsableComponent("CustomPanel")]
    [PDFJSConvertor("mycompany.convertors.custom_panel")]
    public class CustomPanel : Panel
    {
        [PDFAttribute("background-pattern")]
        public string BackgroundPattern { get; set; }
        
        [PDFElement("Header")]
        public Component Header { get; set; }
        
        [PDFArray(typeof(Component))]
        [PDFElement("Items")]
        public ComponentList Items { get; private set; }
        
        public CustomPanel()
        {
            Items = new ComponentList(this, ObjectTypes.Component);
        }
        
        protected override void DoBuildLayout(LayoutContext context, Rect bounds)
        {
            // Custom layout logic
        }
    }
}

private static object _applicationlock = new object();

public static ParserClassDefinition GetClassDefinition(...)
{
    lock (_applicationlock)
    {
        // Thread-safe type resolution
    }
}

[PDFParsableComponent("DataTable")]
public class DataTable : Panel { /* ... */ }

[PDFParsableComponent("StatCard")]
public class StatCard : Panel { /* ... */ }

public class DatabaseImageFactory : ImageFactoryBase
{
    protected override async Task<ImageData> DoLoadImageDataAsync(...)
    {
        // Load from database
    }
}

namespace MyCompany.Reports
{
    public class MonthlyReportController
    {
        [PDFOutlet(Required = true)]
        public StatCard SalesCard { get; set; }
        
        [PDFOutlet]
        public DataTable DataTable { get; set; }
        
        [PDFOutlet]
        public Image CompanyLogo { get; set; }

        public void Init(InitContext context)
        {
            CompanyLogo.Source = "db://logos/company-logo";
        }

        public void LoadData(LoadContext context)
        {
            var data = FetchMonthlyData();
            DataTable.DataSource = data;
            SalesCard.Value = data.Sum(d => d.Amount).ToString("C");
        }

        private List<SalesData> FetchMonthlyData()
        {
            // Database query
            return new List<SalesData>();
        }
    }
}

using (var stream = File.OpenRead("MonthlyReport.pdfx"))
{
    var doc = Document.ParseDocument(stream, ParseSourceType.DynamicContent);
    doc.ProcessDocument("MonthlyReport.pdf");
}