Merge pull request #1057 from anti-the-social/Numbering-start-from-number-doesn't-work

Numbering start from number doesn't work fix

demo/68-numbering-instances-and-starting-number.ts

@@ -0,0 +1,86 @@
+import * as fs from "fs";
+import { Document, Packer, Paragraph, PageNumberFormat} from "../build";
+
+const doc = new Document({
+  numbering:{
+    config:[
+      {
+        reference: 'ref1',
+        levels: [
+          {
+            level: 0,
+            format: PageNumberFormat.DECIMAL,
+            text: '%1',
+            start: 10,
+          }
+        ],
+      },
+      {
+        reference: 'ref2',
+        levels: [
+          {
+            level: 0,
+            format: PageNumberFormat.DECIMAL,
+            text: '%1'
+          }
+        ],
+      },
+    ]
+  },
+  sections: [{
+    children: [
+      new Paragraph({
+        text: "REF1 - inst:0 - lvl:0",
+        numbering : {
+          reference: 'ref1',
+          instance: 0,
+          level: 0,
+        }
+      }),
+      new Paragraph({
+        text: "REF1 - inst:0 - lvl:0",
+        numbering : {
+          reference: 'ref1',
+          instance: 0,
+          level: 0,
+        }
+      }),
+      new Paragraph({
+        text: "REF1 - inst:1 - lvl:0",
+        numbering : {
+          reference: 'ref1',
+          instance: 1,
+          level: 0,
+        },
+      }),
+      new Paragraph({
+        text: "REF1 - inst:1 - lvl:0",
+        numbering : {
+          reference: 'ref1',
+          instance: 1,
+          level: 0,
+        }
+      }),
+      new Paragraph({
+        text: "REF2 - inst:0 - lvl:0",
+        numbering : {
+          reference: 'ref2',
+          instance: 1,
+          level: 0,
+        }
+      }),
+      new Paragraph({
+        text: "REF2 - inst:0 - lvl:0",
+        numbering : {
+          reference: 'ref2',
+          instance: 1,
+          level: 0,
+        }
+      })
+    ],
+  }]
+});
+
+Packer.toBuffer(doc).then((buffer) => {
+    fs.writeFileSync("My Document.docx", buffer);
+});

src/file/numbering/numbering.spec.ts

@@ -112,5 +112,26 @@ describe("Numbering", () => {
                 expect(numbering.ConcreteNumbering).to.have.length(2);
             });
         });
+        describe("#referenceConfigMap", () => {
+            it("should store level configs into referenceConfigMap", () => {
+                const numbering = new Numbering({
+                    config: [
+                        {
+                            reference: "test-reference",
+                            levels: [
+                                {
+                                    level: 0,
+                                    start: 10,
+                                },
+                            ],
+                        },
+                    ],
+                });
+                numbering.createConcreteNumberingInstance("test-reference", 0);
+                const referenceConfig = numbering.ReferenceConfig[0];
+                const zeroLevelConfig = referenceConfig[0];
+                expect(zeroLevelConfig.start).to.be.equal(10);
+            });
+        });
     });
 });

src/file/numbering/numbering.ts

@@ -29,6 +29,7 @@ export interface INumberingOptions {
 export class Numbering extends XmlComponent {
     private readonly abstractNumberingMap = new Map<string, AbstractNumbering>();
     private readonly concreteNumberingMap = new Map<string, ConcreteNumbering>();
+    private readonly referenceConfigMap = new Map<string, object>();
 
     constructor(options: INumberingOptions) {
         super("w:numbering");
@@ -174,6 +175,7 @@ export class Numbering extends XmlComponent {
 
         for (const con of options.config) {
             this.abstractNumberingMap.set(con.reference, new AbstractNumbering(uniqueNumericId(), con.levels));
+            this.referenceConfigMap.set(con.reference, con.levels);
         }
     }
 
@@ -201,22 +203,33 @@ export class Numbering extends XmlComponent {
             return;
         }
 
-        this.concreteNumberingMap.set(
+        const concreteNumberingSettings = {
-            fullReference,
+            numId: uniqueNumericId(),
-            new ConcreteNumbering({
+            abstractNumId: abstractNumbering.id,
-                numId: uniqueNumericId(),
+            reference,
-                abstractNumId: abstractNumbering.id,
+            instance,
-                reference,
+            overrideLevel: {
-                instance,
+                num: 0,
-                overrideLevel: {
+                start: 1,
-                    num: 0,
+            },
-                    start: 1,
+        };
-                },
+
-            }),
+        const referenceConfigLevels = this.referenceConfigMap.get(reference);
-        );
+        const firstLevelStartNumber = referenceConfigLevels && referenceConfigLevels[0].start;
+        if (firstLevelStartNumber && Number.isInteger(firstLevelStartNumber)) {
+            concreteNumberingSettings.overrideLevel = {
+                num: 0,
+                start: firstLevelStartNumber,
+            };
+        }
+
+        this.concreteNumberingMap.set(fullReference, new ConcreteNumbering(concreteNumberingSettings));
     }
 
     public get ConcreteNumbering(): ConcreteNumbering[] {
         return Array.from(this.concreteNumberingMap.values());
     }
+    public get ReferenceConfig(): object[] {
+        return Array.from(this.referenceConfigMap.values());
+    }
 }