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
    new ImageFactorySvg(),        // .*\.svg$
    new ImageFactorySvgDataUrl(). // data:image/svg
};

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

// 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;
}

// Default registrations in ParsingOptions constructor
Namespaces.Add(new NamespaceMappingOption()  //legacy mapping to Scryber.Components
{ 
    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() //legacy mapping to Scryber.Data
{ 
    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() //html namespace => Scryber.Html.Components
{ 
    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() //svg namespace => Scryber.Svg.Components
{ 
    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;
}

using Scryber.Generation;
using Scryber.Components;

namespace MyCompany.CustomComponents
{
    [PDFParsableComponent("CustomPanel")]
    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
    }
}