Enable package initialization that doesn't get copied (#1825)

With the pipelining added in 3.0.1 used internally for creating
packages, it caused any initializing of the package (i.e. from FlatOpc)
to be repeated on clones which we don't want. This fixes the templates
(both FlatOpc and document templates) from not being captures in the
package creation but kept separate for an initialization step.

Fixes #1814

Author: twsouthwick

src/DocumentFormat.OpenXml.Framework/Builder/IPackageBuilder{TPackage}.cs

@@ -11,7 +11,7 @@ namespace DocumentFormat.OpenXml.Builder;
 /// <summary>
 /// A delegate for initializing a package.
 /// </summary>
-internal delegate void PackageInitializerDelegate<TPackage>(TPackage package);
+internal delegate void PackageDelegate<TPackage>(TPackage package);
 
 /// <summary>
 /// Defines a builder to create an initialization pipeline for a <typeparamref name="TPackage"/>.
@@ -32,7 +32,7 @@ internal interface IPackageBuilder<TPackage>
     /// </summary>
     /// <param name="configure">The middleware to add.</param>
     /// <returns>The <see cref="IPackageBuilder{TPackage}"/>.</returns>
-    IPackageBuilder<TPackage> Use(Func<PackageInitializerDelegate<TPackage>, PackageInitializerDelegate<TPackage>> configure);
+    IPackageBuilder<TPackage> Use(Func<PackageDelegate<TPackage>, PackageDelegate<TPackage>> configure);
 
     /// <summary>
     /// Create a copy of the builder that will be independent of the original, but retains the existing middleware and properties.

src/DocumentFormat.OpenXml.Framework/Builder/IPackageFactory.cs

@@ -22,4 +22,8 @@ internal interface IPackageFactory<TPackage>
     /// <param name="initializer">Initializer for the package.</param>
     /// <returns>The created package.</returns>
     TPackage Create(IPackageInitializer initializer);
+
+    PackageDelegate<TPackage>? Template { get; set; }
+
+    IPackageFactory<TPackage> New();
 }

src/DocumentFormat.OpenXml.Framework/Builder/OpenXmlPackageBuilder.cs

@@ -13,9 +13,9 @@ internal abstract class OpenXmlPackageBuilder<TPackage> : IPackageBuilder<TPacka
     where TPackage : OpenXmlPackage
 {
     private Dictionary<string, object?>? _properties;
-    private PackageInitializerDelegate<TPackage>? _pipeline;
+    private PackageDelegate<TPackage>? _pipeline;
     private bool _isLocked;
-    private List<Func<PackageInitializerDelegate<TPackage>, PackageInitializerDelegate<TPackage>>>? _middleware;
+    private List<Func<PackageDelegate<TPackage>, PackageDelegate<TPackage>>>? _middleware;
 
     public IDictionary<string, object?> Properties => _properties ??= new();
 
@@ -37,7 +37,7 @@ internal OpenXmlPackageBuilder(OpenXmlPackageBuilder<TPackage>? parent)
         }
     }
 
-    public IPackageBuilder<TPackage> Use(Func<PackageInitializerDelegate<TPackage>, PackageInitializerDelegate<TPackage>> configure)
+    public IPackageBuilder<TPackage> Use(Func<PackageDelegate<TPackage>, PackageDelegate<TPackage>> configure)
     {
         if (_isLocked)
         {
@@ -58,7 +58,7 @@ public IPackageBuilder<TPackage> Use(Func<PackageInitializerDelegate<TPackage>,
     public IPackageFactory<TPackage> Build() => new Factory(Create, BuildPipeline());
 
     [MemberNotNull(nameof(_pipeline))]
-    private PackageInitializerDelegate<TPackage> BuildPipeline()
+    private PackageDelegate<TPackage> BuildPipeline()
     {
         _isLocked = true;
 
@@ -68,11 +68,11 @@ private PackageInitializerDelegate<TPackage> BuildPipeline()
         }
 
         var factory = new PackageFactoryFeature(Clone());
-        var pipeline = new PackageInitializerDelegate<TPackage>(factory.PipelineTerminator);
+        var pipeline = new PackageDelegate<TPackage>(factory.PipelineTerminator);
 
         if (_middleware is not null)
         {
-            for (int i = _middleware.Count - 1; i >= 0; i--)
+            for (var i = _middleware.Count - 1; i >= 0; i--)
             {
                 pipeline = _middleware[i](pipeline);
             }
@@ -84,20 +84,27 @@ private PackageInitializerDelegate<TPackage> BuildPipeline()
     private sealed class Factory : IPackageFactory<TPackage>
     {
         private readonly Func<TPackage> _package;
-        private readonly PackageInitializerDelegate<TPackage> _pipeline;
+        private readonly PackageDelegate<TPackage> _pipeline;
 
-        public Factory(Func<TPackage> package, PackageInitializerDelegate<TPackage> pipeline)
+        public Factory(Func<TPackage> package, PackageDelegate<TPackage> pipeline)
         {
             _package = package;
             _pipeline = pipeline;
         }
 
+        public PackageDelegate<TPackage>? Template { get; set; }
+
+        public IPackageFactory<TPackage> New() => new Factory(_package, _pipeline);
+
         public TPackage Create(IPackageInitializer initializer)
         {
             var package = _package();
 
             initializer.Initialize(package);
+
+            package.Features.Set<TemplateFeature>(new TemplateFeature(Template));
             _pipeline(package);
+            package.Features.Set<TemplateFeature>(null);
 
             return package;
         }
@@ -114,6 +121,23 @@ private sealed class PackageFactoryFeature : IPackageFactoryFeature<TPackage>
         public void PipelineTerminator(TPackage package)
         {
             package.Features.Set<IPackageFactoryFeature<TPackage>>(this);
+
+            if (package.Features.Get<TemplateFeature>() is { } feature)
+            {
+                feature.Initialize(package);
+            }
         }
     }
+
+    private sealed class TemplateFeature
+    {
+        private readonly PackageDelegate<TPackage>? _initializer;
+
+        public TemplateFeature(PackageDelegate<TPackage>? initializer)
+        {
+            _initializer = initializer;
+        }
+
+        public void Initialize(TPackage package) => _initializer?.Invoke(package);
+    }
 }

src/DocumentFormat.OpenXml.Framework/Builder/OpenXmlPackageBuilderExtensions.cs

@@ -74,14 +74,14 @@ internal static TPackage Open<TPackage>(this IPackageFactory<TPackage> builder)
         where TPackage : OpenXmlPackage
         => builder.Create(new StreamPackageFeature(new MemoryStream(), PackageOpenMode.Create));
 
-    internal static TPackage Use<TPackage>(this TPackage package, PackageInitializerDelegate<TPackage> action)
+    internal static TPackage Use<TPackage>(this TPackage package, PackageDelegate<TPackage> action)
         where TPackage : OpenXmlPackage
     {
         action(package);
         return package;
     }
 
-    internal static IPackageBuilder<TPackage> Use<TPackage>(this IPackageBuilder<TPackage> builder, PackageInitializerDelegate<TPackage> action)
+    internal static IPackageBuilder<TPackage> Use<TPackage>(this IPackageBuilder<TPackage> builder, PackageDelegate<TPackage> action)
         where TPackage : OpenXmlPackage
         => builder.Use((package, next) =>
         {
@@ -92,7 +92,7 @@ internal static IPackageBuilder<TPackage> Use<TPackage>(this IPackageBuilder<TPa
     /// <summary>
     /// Adds the <paramref name="middleware"/> to the builder for initializing a package.
     /// </summary>
-    public static IPackageBuilder<TPackage> Use<TPackage>(this IPackageBuilder<TPackage> builder, Action<TPackage, PackageInitializerDelegate<TPackage>> middleware)
+    public static IPackageBuilder<TPackage> Use<TPackage>(this IPackageBuilder<TPackage> builder, Action<TPackage, PackageDelegate<TPackage>> middleware)
         where TPackage : OpenXmlPackage
     {
         if (builder is null)

src/DocumentFormat.OpenXml.Framework/Builder/TemplateBuilderExtensions.cs

@@ -16,99 +16,30 @@ namespace DocumentFormat.OpenXml.Builder;
 [Obsolete(ExperimentalApis.Message, DiagnosticId = ExperimentalApis.PackageBuilder, UrlFormat = ExperimentalApis.UrlFormat)]
 internal static class TemplateBuilderExtensions
 {
-    /// <summary>
-    /// Adds a template to the current <paramref name="builder"/>.
-    /// </summary>
-    public static IPackageBuilder<TPackage> UseTemplate<TPackage, TType>(this IPackageBuilder<TPackage> builder, string path, TType type)
+    public static IPackageFactory<TPackage> WithTemplate<TPackage, TType>(this IPackageFactory<TPackage> packageFactory, string path, TType type)
         where TPackage : OpenXmlPackage
         where TType : struct
-        => builder.CreateTemplateBuilder(
-            builder => builder.Open(path, PackageOpenMode.Read),
-            package =>
-            {
-                var typeFeature = package.Features.GetRequired<IDocumentTypeFeature<TType>>();
-
-                if (!EqualityComparer<TType>.Default.Equals(typeFeature.Current, type))
-                {
-                    typeFeature.ChangeDocumentType(type);
-                }
-            });
+        => packageFactory.WithTemplate(templateFactory => templateFactory.Open(path, PackageOpenMode.Read), type);
 
-    internal static IPackageBuilder<TPackage> CreateTemplateBuilder<TPackage>(this IPackageBuilder<TPackage> builder, Func<IPackageFactory<TPackage>, TPackage> templateFactory, Action<TPackage>? onLoad = null)
+    public static IPackageFactory<TPackage> WithTemplate<TPackage, TType>(this IPackageFactory<TPackage> factory, Func<IPackageFactory<TPackage>, TPackage> templateActivator, TType type)
         where TPackage : OpenXmlPackage
-        => new TemplateBuilder<TPackage>(builder, templateFactory, onLoad);
-
-    private sealed class TemplateBuilder<TPackage> : IPackageBuilder<TPackage>
-      where TPackage : OpenXmlPackage
+        where TType : struct
     {
-        private readonly IPackageBuilder<TPackage> _otherBuilder;
-        private readonly IPackageBuilder<TPackage> _templateBuilder;
-        private readonly Func<IPackageFactory<TPackage>, TPackage> _templateFactory;
-        private readonly Action<TPackage>? _onLoad;
-
-        public TemplateBuilder(
-            IPackageBuilder<TPackage> other,
-            Func<IPackageFactory<TPackage>, TPackage> templateFactory,
-            Action<TPackage>? onLoad)
-        {
-            _otherBuilder = other;
-            _templateBuilder = other.Clone();
-            _templateFactory = templateFactory;
-            _onLoad = onLoad;
-        }
-
-        public IDictionary<string, object?> Properties => _otherBuilder.Properties;
-
-        public IPackageBuilder<TPackage> Clone() => new TemplateBuilder<TPackage>(_otherBuilder.Clone(), _templateFactory, _onLoad);
-
-        public IPackageBuilder<TPackage> Use(Func<PackageInitializerDelegate<TPackage>, PackageInitializerDelegate<TPackage>> configure)
-        {
-            _otherBuilder.Use(configure);
-            return this;
-        }
-
-        public IPackageFactory<TPackage> Build() => new TemplateFactory(_otherBuilder.Build(), this);
+        var templateFactory = factory.New();
 
-        private sealed class TemplateFactory : IPackageFactory<TPackage>
+        factory.Template += package =>
         {
-            private readonly IPackageFactory<TPackage> _factory;
-            private readonly TemplateBuilder<TPackage> _template;
-
-            public TemplateFactory(IPackageFactory<TPackage> factory, TemplateBuilder<TPackage> template)
-            {
-                _factory = factory;
-                _template = template;
-            }
+            var template = templateActivator(templateFactory);
+            template.Clone(package);
 
-            public TPackage Create(IPackageInitializer initializer)
-                => _factory.Create(new Initializer(initializer, _template));
+            var typeFeature = package.Features.GetRequired<IDocumentTypeFeature<TType>>();
 
-            private sealed class Initializer : IPackageInitializer
+            if (!EqualityComparer<TType>.Default.Equals(typeFeature.Current, type))
             {
-                private readonly IPackageInitializer _other;
-                private readonly TemplateBuilder<TPackage> _template;
-
-                public Initializer(IPackageInitializer other, TemplateBuilder<TPackage> template)
-                {
-                    _other = other;
-                    _template = template;
-                }
-
-                public void Initialize(OpenXmlPackage package)
-                {
-                    _other.Initialize(package);
-                    _template.LoadTemplate((TPackage)package);
-                }
+                typeFeature.ChangeDocumentType(type);
             }
-        }
-
-        private void LoadTemplate(TPackage package)
-        {
-            using var template = _templateFactory(_templateBuilder.Build());
-
-            template.Clone(package);
+        };
 
-            _onLoad?.Invoke(package);
-        }
+        return factory;
     }
 }