Eliminate wrapping factories

Author: langsamu

src/Wrapper.ts

@@ -14,6 +14,10 @@ export class Wrapper {
         this.#factory = factory
     }
 
+    public static as<T>(constructor: new (term: Term, dataset: DatasetCore, factory: DataFactory) => T): ValueMapping<T> {
+        return (n: Wrapper) => new constructor(n.term, n.dataset, n.factory)
+    }
+
     get dataset(): DatasetCore {
         return this.#dataset
     }

test/unit/example.test.ts

@@ -25,7 +25,7 @@ prefix : <https://example.org/>
         dataset.addQuads(new Parser().parse(rdf));
         const x = DataFactory.namedNode("x")
 
-        const p = Parent.wrap(x, dataset, DataFactory)
+        const p = new Parent(x, dataset, DataFactory)
 
 
         assert.equal("o1", p.hasString)
@@ -39,7 +39,7 @@ prefix : <https://example.org/>
         assert.equal("x", p.hasString)
 
         const newNode = DataFactory.namedNode("example.com/s")
-        const newChild = Child.wrap(newNode, dataset, DataFactory)
+        const newChild = new Child(newNode, dataset, DataFactory)
         newChild.hasName = "new name"
         p.hasChild = newChild
 
@@ -71,7 +71,7 @@ prefix : <https://example.org/>
         dataset.addQuads(new Parser().parse(rdf))
         const x = DataFactory.namedNode("x")
 
-        const someModelClass = SomeModelClass.wrap(x, dataset, DataFactory)
+        const someModelClass = new SomeModelClass(x, dataset, DataFactory)
 
         assert.equal("o1", someModelClass.p1)
 

test/unit/model/Child.ts

@@ -1,20 +1,7 @@
 import { TermMappings, ValueMappings, Wrapper } from "rdfjs-wrapper"
 import { Vocabulary } from "../Vocabulary.js"
-import type { DataFactory, DatasetCore, Term } from "@rdfjs/types"
 
 export class Child extends Wrapper {
-    private constructor(node: Term, dataset: DatasetCore, factory: DataFactory) {
-        super(node, dataset, factory)
-    }
-
-    public static wrap(node: Term, dataset: DatasetCore, factory: DataFactory): Child {
-        return new Child(node, dataset, factory)
-    }
-
-    public static wrap2(node: Wrapper): Child {
-        return Child.wrap(node.term, node.dataset, node.factory)
-    }
-
     public get hasName(): string | undefined {
         return this.singular(Vocabulary.hasName, ValueMappings.literalToString)
     }

test/unit/model/Parent.ts

@@ -1,17 +1,8 @@
 import { Child } from "./Child.js"
 import { TermMappings, ValueMappings, Wrapper } from "rdfjs-wrapper"
 import { Vocabulary } from "../Vocabulary.js"
-import type { DataFactory, DatasetCore, Term } from "@rdfjs/types"
 
 export class Parent extends Wrapper {
-    private constructor(node: Term, dataset: DatasetCore, factory: DataFactory) {
-        super(node, dataset, factory)
-    }
-
-    public static wrap(node: Term, dataset: DatasetCore, factory: DataFactory): Parent {
-        return new Parent(node, dataset, factory)
-    }
-
     public get hasString(): string | undefined {
         return this.singular(Vocabulary.hasString, ValueMappings.literalToString)
     }
@@ -21,14 +12,14 @@ export class Parent extends Wrapper {
     }
 
     public get hasChild(): Child {
-        return this.singular(Vocabulary.hasChild, Child.wrap2)
+        return this.singular(Vocabulary.hasChild, Wrapper.as(Child))
     }
 
     public set hasChild(value: Child) {
-        this.overwriteNullable(Vocabulary.hasChild, value, Child.wrap2)
+        this.overwriteNullable(Vocabulary.hasChild, value, Wrapper.as(Child))
     }
 
     public get hasChildSet(): Set<Child> {
-        return this.objects(Vocabulary.hasChildSet, Child.wrap2, Child.wrap2)
+        return this.objects(Vocabulary.hasChildSet, Wrapper.as(Child), Wrapper.as(Child))
     }
 }

test/unit/model/SomeModelClass.ts

@@ -1,22 +1,6 @@
 import { getter, GetterArity, setter, SetterArity, TermMappings, ValueMappings, Wrapper } from "rdfjs-wrapper"
-import type { DataFactory, DatasetCore, Term } from "@rdfjs/types"
 
 export class SomeModelClass extends Wrapper {
-    private constructor(node: Term, dataset: DatasetCore, factory: DataFactory) {
-        super(node, dataset, factory)
-    }
-
-    static wrap(wrapper: Wrapper): SomeModelClass
-    static wrap(n: Term, dataset: DatasetCore, factory: DataFactory): SomeModelClass
-    static wrap(nodeOrWrapper: Term | Wrapper, dataset?: DatasetCore, factory?: DataFactory): SomeModelClass {
-        if (dataset !== undefined && factory !== undefined) {
-            return new SomeModelClass(nodeOrWrapper as Term, dataset, factory)
-        } else {
-            const {term, dataset, factory} = nodeOrWrapper as Wrapper
-            return new SomeModelClass(term, dataset, factory)
-        }
-    }
-
     @getter("https://example.org/hasString", GetterArity.Singular, ValueMappings.literalToString)
     get p1(): string {
         throw new Error