@shaclmate/compiler 2.0.20 → 2.0.23

package/dist/generators/ts/Type.js

@@ -1,6 +1,4 @@
-import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { rdfjsTermExpression } from "./_ObjectType/rdfjsTermExpression.js";
 import { objectInitializer } from "./objectInitializer.js";
 /**
  * Abstract base class for generating TypeScript expressions and statemenst in the TypeScript generator.
@@ -8,46 +6,19 @@ import { objectInitializer } from "./objectInitializer.js";
  * Subclasses are used for both property types (c.f., property* methods) and node/object types.
  */
 export class Type {
-    dataFactoryVariable;
-    constructor({ dataFactoryVariable, }) {
-        this.dataFactoryVariable = dataFactoryVariable;
-    }
-    /**
-     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
-     */
-    get discriminatorProperty() {
-        return Maybe.empty();
-    }
-    /**
-     * Element object for a JSON Forms UI schema.
-     */
-    jsonUiSchemaElement(_parameters) {
-        return Maybe.empty();
-    }
-    /**
-     * Reusable function, type, and other declarations that are not particular to this type but that type-specific code
-     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
-     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
-     * as a snippet and reference it.
-     *
-     * The generator deduplicates snippet declarations across all types before adding them to the source.
-     */
-    snippetDeclarations(_features) {
-        return [];
-    }
     /**
      * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
      *
      * This method is called in two contexts:
-     * (1) By an ObjectType.Property. The property expects a basic graph pattern (subject, property path, property object). The property calls this method to get additional triples in which the propertyObject is the subject. For example, if the type is a nested object, it would include (propertyObject, nestedPredicate, nestedObject) triples.
-     * (2) By another Type. For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items.
-     *
-     * Term types with no additional properties should return an empty array.
+     * (1) When an instance of the type is an "object" of a property.
+     *     This method should return a BGP (variables.subject, variables.predicate, variables.object) and recursively call itself with the variables.object as a "subject" context.
+     * (2) When an instance of the type is a "subject".
+     *     For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items. Term types with no additional patterns should return an empty array.
      */
-    sparqlConstructTemplateTriples({ context, variables, }) {
+    sparqlConstructTemplateTriples({ allowIgnoreRdfType, context, variables, }) {
         switch (context) {
-            case "property": {
-                const objectPrefix = `${this.dataFactoryVariable}.variable!(`;
+            case "object": {
+                const objectPrefix = "dataFactory.variable!(";
                 const objectSuffix = ")";
                 invariant(variables.object.startsWith(objectPrefix));
                 invariant(variables.object.endsWith(objectSuffix));
@@ -58,14 +29,15 @@ export class Type {
                         subject: variables.subject,
                     }),
                 ].concat(this.sparqlConstructTemplateTriples({
-                    context: "type",
+                    allowIgnoreRdfType,
+                    context: "subject",
                     variables: {
                         subject: variables.object,
                         variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
                     },
                 }));
             }
-            case "type":
+            case "subject":
                 return [];
         }
     }
@@ -74,10 +46,10 @@ export class Type {
      *
      * See note in sparqlConstructTemplateTriples re: how this method is used.
      */
-    sparqlWherePatterns({ context, variables, }) {
+    sparqlWherePatterns({ allowIgnoreRdfType, context, variables, }) {
         switch (context) {
-            case "property": {
-                const objectPrefix = `${this.dataFactoryVariable}.variable!(`;
+            case "object": {
+                const objectPrefix = "dataFactory.variable!(";
                 const objectSuffix = ")";
                 invariant(variables.object.startsWith(objectPrefix));
                 invariant(variables.object.endsWith(objectSuffix));
@@ -91,28 +63,59 @@ export class Type {
                         type: '"bgp"',
                     }),
                 ].concat(this.sparqlWherePatterns({
-                    context: "type",
+                    allowIgnoreRdfType,
+                    context: "subject",
                     variables: {
                         subject: variables.object,
                         variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
                     },
                 }));
             }
-            case "type":
+            case "subject":
                 return [];
         }
     }
-    /**
-     * Imports necessary to use this type.
-     */
-    useImports(_features) {
-        return [];
+}
+(function (Type) {
+    class JsonName {
+        /**
+         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
+         */
+        optional;
+        /**
+         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         */
+        requiredName;
+        constructor(requiredName, parameters) {
+            this.optional = !!parameters?.optional;
+            this.requiredName = requiredName;
+        }
+        toString() {
+            return this.optional
+                ? `(${this.requiredName}) | undefined`
+                : this.requiredName;
+        }
     }
-    rdfjsTermExpression(rdfjsTerm) {
-        return rdfjsTermExpression({
-            dataFactoryVariable: this.dataFactoryVariable,
-            rdfjsTerm,
-        });
+    Type.JsonName = JsonName;
+    class GraphqlName {
+        /**
+         * Is the type nullable in GraphQL?
+         */
+        nullable;
+        /**
+         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         */
+        nullableName;
+        constructor(nullableName, parameters) {
+            this.nullable = !!parameters?.nullable;
+            this.nullableName = nullableName;
+        }
+        toString() {
+            return this.nullable
+                ? this.nullableName
+                : `new graphql.GraphQLNonNull(${this.nullableName})`;
+        }
     }
-}
+    Type.GraphqlName = GraphqlName;
+})(Type || (Type = {}));
 //# sourceMappingURL=Type.js.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -1,14 +1,13 @@
 import type * as ast from "../../ast/index.js";
+import { ObjectType } from "./ObjectType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
     private cachedObjectTypePropertiesByIdentifier;
     private cachedObjectTypesByIdentifier;
-    private readonly dataFactoryVariable;
-    constructor({ dataFactoryVariable }: {
-        dataFactoryVariable: string;
-    });
+    private cachedObjectUnionTypesByIdentifier;
+    createObjectTypeFromAstType(astType: ast.ObjectType): ObjectType;
     createTypeFromAstType(astType: ast.Type): Type;
-    private createObjectTypeFromAstType;
     private createObjectTypePropertyFromAstProperty;
+    private createObjectUnionTypeFromAstType;
 }
 //# sourceMappingURL=TypeFactory.d.ts.map