@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/generators/ts/ObjectIntersectionType.js

@@ -0,0 +1,204 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { ObjectIntersectionType__fromRdfResourceFunction } from "./_ObjectIntersectionType/ObjectIntersectionType__fromRdfResourceFunction.js";
+import { ObjectIntersectionType__toRdfResourceFunction } from "./_ObjectIntersectionType/ObjectIntersectionType__toRdfResourceFunction.js";
+import { ObjectIntersectionType_createFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_createFunction.js";
+import { ObjectIntersectionType_createFunctionParameters } from "./_ObjectIntersectionType/ObjectIntersectionType_createFunctionParameters.js";
+import { ObjectIntersectionType_createUnsafeFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_createUnsafeFunction.js";
+import { ObjectIntersectionType_focusSparqlConstructTriplesFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_focusSparqlConstructTriplesFunction.js";
+import { ObjectIntersectionType_focusSparqlWherePatternsFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_focusSparqlWherePatternsFunction.js";
+import { ObjectIntersectionType_fromJsonObjectFunctionExpression, ObjectIntersectionType_fromJsonObjectFunctionType, } from "./_ObjectIntersectionType/ObjectIntersectionType_fromJsonObjectFunction.js";
+import { ObjectIntersectionType_fromRdfResourceFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceFunction.js";
+import { ObjectIntersectionType_fromRdfResourceValuesFunctionExpression, ObjectIntersectionType_fromRdfResourceValuesFunctionType, } from "./_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceValuesFunction.js";
+import { ObjectIntersectionType_toJsonObjectFunctionExpression } from "./_ObjectIntersectionType/ObjectIntersectionType_toJsonObjectFunction.js";
+import { ObjectIntersectionType_toRdfResourceFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceFunction.js";
+import { ObjectIntersectionType_toRdfResourceValuesFunctionExpression } from "./_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceValuesFunction.js";
+import { ObjectIntersectionType_typeGuardFunction } from "./_ObjectIntersectionType/ObjectIntersectionType_typeGuardFunction.js";
+import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_sparqlConstructQueryFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryFunction.js";
+import { ObjectType_sparqlConstructQueryStringFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunction.js";
+import { AbstractIntersectionType } from "./AbstractIntersectionType.js";
+import { DeclaredCallable } from "./DeclaredCallable.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+export class ObjectIntersectionType extends AbstractIntersectionType {
+    fromJsonObjectFunctionExpression = ObjectIntersectionType_fromJsonObjectFunctionExpression;
+    fromJsonObjectFunctionType = ObjectIntersectionType_fromJsonObjectFunctionType;
+    fromRdfResourceValuesFunctionExpression = ObjectIntersectionType_fromRdfResourceValuesFunctionExpression;
+    fromRdfResourceValuesFunctionType = ObjectIntersectionType_fromRdfResourceValuesFunctionType;
+    toJsonObjectFunctionExpression = ObjectIntersectionType_toJsonObjectFunctionExpression;
+    toRdfResourceValuesFunctionExpression = ObjectIntersectionType_toRdfResourceValuesFunctionExpression;
+    discriminatedType;
+    identifierType;
+    kind = "ObjectIntersection";
+    constructor({ identifierType, ...superParameters }) {
+        super(superParameters);
+        this.discriminatedType = this.name.map((name) => ({
+            discriminantProperty: {
+                name: this.configuration.objectDiscriminantProperty.name,
+                values: [name],
+            },
+            expression: code `${name}.Discriminated`,
+        }));
+        this.identifierType = identifierType;
+    }
+    get _fromRdfResourceFunction() {
+        return ObjectIntersectionType__fromRdfResourceFunction.call(this);
+    }
+    get _toRdfResourceFunction() {
+        return ObjectIntersectionType__toRdfResourceFunction.call(this);
+    }
+    get createFunction() {
+        return ObjectIntersectionType_createFunction.call(this);
+    }
+    get createFunctionParameters() {
+        return ObjectIntersectionType_createFunctionParameters.call(this);
+    }
+    get focusSparqlConstructTriplesFunction() {
+        return ObjectIntersectionType_focusSparqlConstructTriplesFunction.call(this);
+    }
+    get focusSparqlWherePatternsFunction() {
+        return ObjectIntersectionType_focusSparqlWherePatternsFunction.call(this);
+    }
+    get fromRdfResourceFunction() {
+        return ObjectIntersectionType_fromRdfResourceFunction.call(this);
+    }
+    get identifierTypeAlias() {
+        return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
+    }
+    get jsonObjectType() {
+        return this.jsonTypeFactory.createJsonIntersectionType(this.members.map((member) => member.type.jsonObjectType), {
+            name: this.name.map((name) => [name, "Json"]).extract(),
+            recursive: this.recursive,
+        });
+    }
+    get jsonValueType() {
+        return this.jsonObjectType;
+    }
+    get objectSetMethodNames() {
+        return ObjectType_objectSetMethodNames.call({
+            name: this.name.unsafeCoerce(),
+            configuration: this.configuration,
+        });
+    }
+    get sparqlConstructQueryFunction() {
+        return ObjectType_sparqlConstructQueryFunction.call({
+            configuration: this.configuration,
+            filterType: this.filterType,
+            _function: this._function.bind(this),
+            focusSparqlConstructTriplesFunction: this.focusSparqlConstructTriplesFunction,
+            focusSparqlWherePatternsFunction: this.focusSparqlWherePatternsFunction,
+            name: this.name,
+            reusables: this.reusables,
+        });
+    }
+    get sparqlConstructQueryStringFunction() {
+        return ObjectType_sparqlConstructQueryStringFunction.call({
+            configuration: this.configuration,
+            filterType: this.filterType,
+            _function: this._function.bind(this),
+            sparqlConstructQueryFunction: this.sparqlConstructQueryFunction,
+            reusables: this.reusables,
+        });
+    }
+    get toRdfResourceFunction() {
+        return ObjectIntersectionType_toRdfResourceFunction.call(this);
+    }
+    get typeGuardFunction() {
+        return ObjectIntersectionType_typeGuardFunction.call(this);
+    }
+    get createUnsafeFunction() {
+        return ObjectIntersectionType_createUnsafeFunction.call(this);
+    }
+    staticModuleDeclarations(name) {
+        const staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+            ...ObjectType_identifierTypeDeclarations.call(this),
+        };
+        function addFunctionDeclaration(function_) {
+            invariant(function_ instanceof DeclaredCallable);
+            staticModuleDeclarations[function_.unqualifiedName] =
+                code `export ${function_.declaration}`;
+        }
+        if (this.configuration.features.has("Object.create")) {
+            staticModuleDeclarations["CreateParameters"] =
+                code `export type CreateParameters<${this.configuration.syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}> = ${this.createFunctionParameters.type.inlineExpression};`;
+            addFunctionDeclaration(this.createFunction);
+            addFunctionDeclaration(this.createUnsafeFunction);
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            addFunctionDeclaration(this._fromRdfResourceFunction);
+            addFunctionDeclaration(this.fromRdfResourceFunction);
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            addFunctionDeclaration(this.focusSparqlConstructTriplesFunction);
+            addFunctionDeclaration(this.focusSparqlWherePatternsFunction);
+            addFunctionDeclaration(this.sparqlConstructQueryFunction);
+            addFunctionDeclaration(this.sparqlConstructQueryStringFunction);
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            addFunctionDeclaration(this._toRdfResourceFunction);
+            addFunctionDeclaration(this.toRdfResourceFunction);
+        }
+        if (this.configuration.features.has("Object.type")) {
+            this.discriminatedType.ifJust(({ discriminantProperty }) => {
+                staticModuleDeclarations["Discriminated"] =
+                    code `export type Discriminated = ${name} & { readonly ${discriminantProperty.name}: ${literalOf(discriminantProperty.values[0])} };`;
+            });
+            this.typeGuardFunction.ifJust(addFunctionDeclaration);
+        }
+        return staticModuleDeclarations;
+    }
+}
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "_fromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "_toRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "createFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "createFunctionParameters", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "focusSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "focusSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "fromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "jsonObjectType", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "sparqlConstructQueryFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "sparqlConstructQueryStringFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "toRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "typeGuardFunction", null);
+__decorate([
+    Memoize()
+], ObjectIntersectionType.prototype, "createUnsafeFunction", null);
+//# sourceMappingURL=ObjectIntersectionType.js.map

package/dist/generators/ts/ObjectSetType.js

@@ -14,7 +14,6 @@ export class ObjectSetType extends AbstractObjectSetType {
 export interface ${syntheticNamePrefix}ObjectSet {
   ${joinCode(this.namedObjectTypes
             .flatMap((namedObjectType) => Object.values(this.methodSignatures(namedObjectType)))
-            .concat(this.namedObjectDiscriminatedUnionTypes.flatMap((namedObjectDiscriminatedUnionType) => Object.values(this.methodSignatures(namedObjectDiscriminatedUnionType))))
             .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
 }
 

package/dist/generators/ts/ObjectType.d.ts

@@ -1,93 +1,122 @@
 import { Maybe } from "purify-ts";
 import { ObjectType_DiscriminantProperty } from "./_ObjectType/ObjectType_DiscriminantProperty.js";
+import { ObjectType_equalsFunctionExpression, ObjectType_equalsFunctionType } from "./_ObjectType/ObjectType_equalsFunction.js";
+import { ObjectType_filterFunctionExpression, ObjectType_filterFunctionType } from "./_ObjectType/ObjectType_filterFunction.js";
+import { ObjectType_filterTypeExpression } from "./_ObjectType/ObjectType_filterTypeExpression.js";
+import { ObjectType_fromJsonObjectFunctionExpression, ObjectType_fromJsonObjectFunctionType } from "./_ObjectType/ObjectType_fromJsonObjectFunction.js";
+import { ObjectType_fromRdfResourceValuesFunctionExpression, ObjectType_fromRdfResourceValuesFunctionType } from "./_ObjectType/ObjectType_fromRdfResourceValuesFunction.js";
+import { ObjectType_hashFunctionExpression, ObjectType_hashFunctionType } from "./_ObjectType/ObjectType_hashFunction.js";
 import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import type { ObjectType_Property } from "./_ObjectType/ObjectType_Property.js";
 import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
-import { AbstractType } from "./AbstractType.js";
+import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
+import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
+import { ObjectType_toJsonObjectFunctionExpression, ObjectType_toJsonObjectFunctionType } from "./_ObjectType/ObjectType_toJsonObjectFunction.js";
+import { ObjectType_toLoggableFunctionExpression, ObjectType_toLoggableFunctionType } from "./_ObjectType/ObjectType_toLoggableFunction.js";
+import { ObjectType_toRdfResourceValuesFunctionExpression, ObjectType_toRdfResourceValuesFunctionType } from "./_ObjectType/ObjectType_toRdfResourceValuesFunction.js";
+import { ObjectType_toStringFunctionExpression, ObjectType_toStringFunctionType } from "./_ObjectType/ObjectType_toStringFunction.js";
+import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunction.js";
+import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunction.js";
+import { AbstractStructuredType } from "./AbstractStructuredType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
+import type { Callable } from "./Callable.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractType {
-    readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
+export declare class ObjectType extends AbstractStructuredType {
+    private readonly rdfTypeProperty;
+    protected equalsFunctionExpression: typeof ObjectType_equalsFunctionExpression;
+    protected equalsFunctionType: typeof ObjectType_equalsFunctionType;
+    protected filterFunctionExpression: typeof ObjectType_filterFunctionExpression;
+    protected filterFunctionType: typeof ObjectType_filterFunctionType;
+    protected filterTypeExpression: typeof ObjectType_filterTypeExpression;
+    protected fromJsonObjectFunctionExpression: typeof ObjectType_fromJsonObjectFunctionExpression;
+    protected fromJsonObjectFunctionType: typeof ObjectType_fromJsonObjectFunctionType;
+    protected fromRdfResourceValuesFunctionExpression: typeof ObjectType_fromRdfResourceValuesFunctionExpression;
+    protected fromRdfResourceValuesFunctionType: typeof ObjectType_fromRdfResourceValuesFunctionType;
+    protected hashFunctionExpression: typeof ObjectType_hashFunctionExpression;
+    protected hashFunctionType: typeof ObjectType_hashFunctionType;
+    protected schemaExpression: typeof ObjectType_schemaExpression;
+    protected schemaTypeExpression: typeof ObjectType_schemaTypeExpression;
+    protected toJsonObjectFunctionExpression: typeof ObjectType_toJsonObjectFunctionExpression;
+    protected toJsonObjectFunctionType: typeof ObjectType_toJsonObjectFunctionType;
+    protected toLoggableFunctionExpression: typeof ObjectType_toLoggableFunctionExpression;
+    protected toLoggableFunctionType: typeof ObjectType_toLoggableFunctionType;
+    protected toRdfResourceValuesFunctionExpression: typeof ObjectType_toRdfResourceValuesFunctionExpression;
+    protected toRdfResourceValuesFunctionType: typeof ObjectType_toRdfResourceValuesFunctionType;
+    protected toStringFunctionExpression: typeof ObjectType_toStringFunctionExpression;
+    protected toStringFunctionType: typeof ObjectType_toStringFunctionType;
+    protected valueSparqlConstructTriplesFunctionExpression: typeof ObjectType_valueSparqlConstructTriplesFunctionExpression;
+    protected valueSparqlWherePatternsFunctionExpression: typeof ObjectType_valueSparqlWherePatternsFunctionExpression;
+    readonly discriminatedType: Maybe<AbstractStructuredType.DiscriminatedType>;
     readonly extern: boolean;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly graphqlArgs: AbstractStructuredType["graphqlArgs"];
+    readonly identifierProperty: Maybe<ObjectType.IdentifierProperty>;
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
     readonly kind = "Object";
-    readonly rdfTypeProperty: Maybe<ObjectType.RdfTypeProperty>;
     readonly recursive: boolean;
     readonly synthetic: boolean;
-    readonly validationFunction: Maybe<Code>;
-    constructor({ discriminantProperty, extern, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }: {
+    readonly validationFunction: AbstractStructuredType["validationFunction"];
+    constructor({ discriminantProperty, extern, identifierProperty, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }: {
         discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
         extern: boolean;
+        identifierProperty: Maybe<ObjectType.IdentifierProperty>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
         lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
         rdfTypeProperty: Maybe<ObjectType.RdfTypeProperty>;
         recursive: boolean;
         synthetic: boolean;
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
-    protected staticModuleDeclarations(name: string): Record<string, Code>;
+    } & ConstructorParameters<typeof AbstractStructuredType>[0]);
+    get _fromRdfResourceFunction(): Callable;
+    get _toRdfResourceFunction(): Callable;
+    get jsonValueType(): AbstractStructuredType["jsonObjectType"];
+    get conversionFunction(): Maybe<AbstractStructuredType.ConversionFunction>;
+    get createFunction(): Callable;
+    get createFunctionParameters(): ObjectType.CreateFunctionParameters;
+    get createUnsafeFunction(): Callable;
     get declaration(): Maybe<Code>;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get fromRdfResourceValuesFunction(): Code;
+    get jsonObjectType(): AbstractStructuredType["jsonObjectType"];
+    get focusSparqlConstructTriplesFunction(): Callable;
+    get focusSparqlWherePatternsFunction(): Callable;
+    get fromRdfResourceFunction(): Callable;
     get fromRdfTypeVariable(): Maybe<Code>;
-    get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
+    get graphqlType(): AbstractStructuredType.GraphqlType;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get properties(): readonly ObjectType.Property[];
     get referencesNamedType(): boolean;
-    get schemaExpression(): Code;
-    get schemaVariable(): Maybe<Code>;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    get sparqlConstructQueryFunction(): Callable;
+    get sparqlConstructQueryStringFunction(): Callable;
+    get toRdfResourceFunction(): Callable;
+    get toRdfResourceValueTypes(): AbstractStructuredType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
-    get typeGuardFunction(): Maybe<Code>;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get constructorParameters(): {
-        hasQuestionToken: boolean;
-        signature: Code;
-        type: {
-            expression: Code;
-        };
-        variable: Code;
-    };
-    protected get createFunction(): Code;
-    protected get thisVariable(): Code;
-    protected get toJsonFunction(): Code;
-    protected get toRdfTypesVariable(): Maybe<Code>;
-    protected get toStringFunction(): Code;
+    get toStringRecordFunction(): Callable;
+    get typeGuardFunction(): Maybe<Callable>;
     protected get inlineExpression(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    protected toStringRecordExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected get thisVariable(): Code;
+    protected propertySubsetExpression(propertyFilter: (property: ObjectType.Property) => boolean): Code;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
     private readonly lazyProperties;
 }
 export declare namespace ObjectType {
+    interface CreateFunctionParameters {
+        readonly hasQuestionToken: boolean;
+        readonly signature: Code;
+        readonly type: {
+            readonly inlineExpression: Code;
+            readonly expression: Code;
+        };
+        readonly variable: Code;
+    }
     const IdentifierProperty: typeof ObjectType_IdentifierProperty;
     type IdentifierProperty = ObjectType_IdentifierProperty;
     type ObjectSetMethodNames = {