@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/AbstractConstruct.d.ts

@@ -0,0 +1,31 @@
+import type { Logger } from "@rdfx/logger";
+import type { Maybe } from "purify-ts";
+import type { Reusables } from "./Reusables.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import type { Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for operations, services, and types.
+ */
+export declare abstract class AbstractConstruct {
+    protected readonly configuration: TsGenerator.Configuration;
+    protected readonly logger: Logger;
+    protected readonly reusables: Reusables;
+    /**
+     * Comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
+    /**
+     * Label from rdfs:label.
+     */
+    readonly label: Maybe<string>;
+    constructor({ comment, configuration, label, logger, reusables, }: {
+        comment: Maybe<string>;
+        configuration: TsGenerator.Configuration;
+        label: Maybe<string>;
+        logger: Logger;
+        reusables: Reusables;
+    });
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
+}
+//# sourceMappingURL=AbstractConstruct.d.ts.map

package/dist/generators/ts/AbstractConstruct.js

@@ -0,0 +1,31 @@
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+/**
+ * Abstract base class for operations, services, and types.
+ */
+export class AbstractConstruct {
+    configuration;
+    logger;
+    reusables;
+    /**
+     * Comment from rdfs:comment.
+     */
+    comment;
+    /**
+     * Label from rdfs:label.
+     */
+    label;
+    constructor({ comment, configuration, label, logger, reusables, }) {
+        this.comment = comment;
+        this.configuration = configuration;
+        this.label = label;
+        this.logger = logger;
+        this.reusables = reusables;
+        this.rdfjsTermExpression = rdfjsTermExpression.bind({
+            imports: this.reusables.imports,
+            logger: this.logger,
+            snippets: this.reusables.snippets,
+        });
+    }
+    rdfjsTermExpression;
+}
+//# sourceMappingURL=AbstractConstruct.js.map

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -1,8 +1,10 @@
+import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { BooleanType } from "./BooleanType.js";
+import type { Callable } from "./Callable.js";
 import type { DateTimeType } from "./DateTimeType.js";
 import type { DateType } from "./DateType.js";
 import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
@@ -14,6 +16,7 @@ import type { LangStringType } from "./LangStringType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
@@ -23,6 +26,7 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
+    readonly discriminatedType: Maybe<AbstractType.DiscriminatedType>;
     abstract readonly kind: "DefaultValue" | "List" | "Option" | "Set";
     /**
      * Container item type.
@@ -36,17 +40,16 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     get recursive(): boolean;
     get referencesNamedType(): boolean;
     protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
-    protected get itemValidationFunctionDefault(): Code;
+    protected get itemValidationFunctionDefault(): Callable;
     protected get schemaInitializers(): readonly Code[];
 }
 export declare namespace AbstractContainerType {
     type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    type DiscriminatedType = AbstractType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | StringType | TermType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;
 }
 //# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/generators/ts/AbstractContainerType.js

@@ -4,13 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export class AbstractContainerType extends AbstractType {
+    discriminatedType = Maybe.empty();
     /**
      * Container item type.
      *
@@ -39,7 +42,7 @@ export class AbstractContainerType extends AbstractType {
         };
     }
     get itemValidationFunctionDefault() {
-        return code `${this.reusables.snippets.identityValidationFunction}`;
+        return new ReferenceCallable(this.reusables.snippets.identityValidationFunction);
     }
     get schemaInitializers() {
         const initializers = super.schemaInitializers.concat();
@@ -78,6 +81,7 @@ __decorate([
             case "Literal":
             case "Object":
             case "ObjectDiscriminatedUnion":
+            case "ObjectIntersection":
             case "String":
             case "Term":
                 return true;
@@ -91,6 +95,5 @@ __decorate([
         }
     }
     AbstractContainerType.isItemType = isItemType;
-    AbstractContainerType.JsonType = AbstractType.JsonType;
 })(AbstractContainerType || (AbstractContainerType = {}));
 //# sourceMappingURL=AbstractContainerType.js.map

package/dist/generators/ts/AbstractDateType.d.ts

@@ -1,23 +1,26 @@
 import { Maybe } from "purify-ts";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDateType extends AbstractTypedLiteralType<Date> {
     protected readonly inlineExpression: Code;
+    protected abstract readonly jsonStringFormat: "date" | "datetime";
     /**
      * Date has no conversion function to avoid source type overlap with other types (e.g., string).
      */
     readonly conversionFunction: Maybe<AbstractTypedLiteralType.ConversionFunction>;
-    readonly equalsFunction: Code;
-    readonly filterFunction: Code;
+    readonly equalsFunction: ReferenceCallable;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
+    readonly fromJsonValueFunction: ReferenceCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Date";
         readonly typeof: "object";
     }];
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["fromJsonExpression"]>[0]): Code;
-    jsonType(): AbstractTypedLiteralType.JsonType;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    get jsonValueType(): AbstractTypedLiteralType.JsonType;
+    toLoggableExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractDateType {

package/dist/generators/ts/AbstractDateType.js

@@ -1,15 +1,24 @@
+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 { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
+import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractTypedLiteralType {
     inlineExpression = code `Date`;
     /**
      * Date has no conversion function to avoid source type overlap with other types (e.g., string).
      */
     conversionFunction = Maybe.empty();
-    equalsFunction = code `${this.reusables.snippets.dateEquals}`;
-    filterFunction = code `${this.reusables.snippets.filterDate}`;
+    equalsFunction = new ReferenceCallable(this.reusables.snippets.dateEquals);
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterDate);
     filterType = code `${this.reusables.snippets.DateFilter}`;
+    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.dateFromJsonString);
     jsTypes = [
         {
             instanceof: "Date",
@@ -17,15 +26,20 @@ export class AbstractDateType extends AbstractTypedLiteralType {
         },
     ];
     schemaType = code `${this.reusables.snippets.DateSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}["@value"]))`;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.dateSparqlWherePatterns);
+    get jsonValueType() {
+        return this.jsonTypeFactory.createJsonStringType({
+            format: this.jsonStringFormat,
+        });
     }
-    jsonType() {
-        return new AbstractTypedLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
+    toLoggableExpression({ variables, }) {
+        return code `${variables.value}.toISOString()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.date(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
 }
+__decorate([
+    Memoize()
+], AbstractDateType.prototype, "jsonValueType", null);
 //# sourceMappingURL=AbstractDateType.js.map

package/dist/generators/ts/AbstractDiscriminatedUnionType.d.ts

@@ -1,72 +1,70 @@
 import { Maybe } from "purify-ts";
 import type { AbstractDiscriminatedUnionType_Discriminant } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_Discriminant.js";
-import { AbstractType } from "./AbstractType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IriType } from "./IriType.js";
+import { AbstractDiscriminatedUnionType_equalsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunction.js";
+import { AbstractDiscriminatedUnionType_filterFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterFunction.js";
+import { AbstractDiscriminatedUnionType_filterTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterTypeExpression.js";
+import { AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonObjectFunction.js";
+import { AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.js";
+import { AbstractDiscriminatedUnionType_hashFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunction.js";
+import { AbstractDiscriminatedUnionType_schemaTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js";
+import { AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js";
+import { AbstractDiscriminatedUnionType_toLoggableFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.js";
+import { AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.js";
+import { AbstractDiscriminatedUnionType_toStringFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toStringFunction.js";
+import { AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.js";
+import { AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import type { ObjectType } from "./ObjectType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractDiscriminatedUnionType<MemberTypeT extends Type> extends AbstractType {
+export declare abstract class AbstractDiscriminatedUnionType<MemberTypeT extends Type> extends AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT> {
     protected readonly discriminant: AbstractDiscriminatedUnionType.Discriminant;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+    protected equalsFunctionExpression: typeof AbstractDiscriminatedUnionType_equalsFunctionExpression;
+    protected filterFunctionExpression: typeof AbstractDiscriminatedUnionType_filterFunctionExpression;
+    protected filterTypeExpression: typeof AbstractDiscriminatedUnionType_filterTypeExpression;
+    protected fromJsonObjectFunctionExpression: typeof AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression;
+    protected fromRdfResourceValuesFunctionExpression: typeof AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression;
+    protected hashFunctionExpression: typeof AbstractDiscriminatedUnionType_hashFunctionExpression;
+    protected schemaTypeExpression: typeof AbstractDiscriminatedUnionType_schemaTypeExpression;
+    protected toJsonObjectFunctionExpression: typeof AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression;
+    protected toLoggableFunctionExpression: typeof AbstractDiscriminatedUnionType_toLoggableFunctionExpression;
+    protected toRdfResourceValuesFunctionExpression: typeof AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression;
+    protected toStringFunctionExpression: typeof AbstractDiscriminatedUnionType_toStringFunctionExpression;
+    protected valueSparqlConstructTriplesFunctionExpression: typeof AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression;
+    protected valueSparqlWherePatternsFunctionExpression: typeof AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression;
+    readonly graphqlArgs: AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>["graphqlArgs"];
+    readonly identifierProperty: Maybe<ObjectType.IdentifierProperty>;
     abstract readonly kind: "ObjectDiscriminatedUnion" | "DiscriminatedUnion";
     readonly recursive: boolean;
-    readonly validationFunction: Maybe<Code>;
-    constructor({ identifierType, members, recursive, ...superParameters }: {
-        identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+    readonly validationFunction: AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>["validationFunction"];
+    constructor({ identifierProperty, members, recursive, ...superParameters }: {
+        identifierProperty: Maybe<ObjectType.IdentifierProperty>;
         members: readonly (Pick<AbstractDiscriminatedUnionType.Member<MemberTypeT>, "type"> & {
             readonly discriminantValue: Maybe<number | string>;
         })[];
         recursive: boolean;
         synthetic: boolean;
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
-    get jsTypes(): AbstractType["jsTypes"];
-    get jsonSchemaFunctionDeclaration(): Code;
-    get jsonTypeAliasDeclaration(): Code;
+    } & ConstructorParameters<typeof AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>>[0]);
+    get jsonValueType(): AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>["jsonValueType"];
+    get conversionFunction(): Maybe<AbstractCompoundType.ConversionFunction>;
+    get discriminatedType(): Maybe<AbstractCompoundType.DiscriminatedType>;
+    get jsonObjectType(): AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>["jsonObjectType"];
+    get graphqlType(): AbstractCompoundType.GraphqlType;
+    get jsTypes(): AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>["jsTypes"];
     get members(): readonly AbstractDiscriminatedUnionType.Member<MemberTypeT>[];
-    get mutable(): boolean;
-    get referencesNamedType(): boolean;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
     protected get inlineExpression(): Code;
     protected get schemaInitializers(): readonly Code[];
     private get conversionFunctionExpression();
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    jsonUiSchemaElement(): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
     private readonly lazyMembers;
 }
 export declare namespace AbstractDiscriminatedUnionType {
     type Discriminant = AbstractDiscriminatedUnionType_Discriminant;
     interface Member<TypeT extends Type> {
-        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly jsonType: Code;
-        readonly jsonTypeCheck: (instance: Code) => Code;
-        readonly primaryDiscriminantValue: AbstractType.DiscriminantProperty.Value;
+        readonly discriminantValues: AbstractCompoundType.DiscriminatedType["discriminantProperty"]["values"];
+        readonly primaryDiscriminantValue: AbstractCompoundType.DiscriminatedType["discriminantProperty"]["values"][number];
         readonly type: TypeT;
         readonly typeCheck: (instance: Code) => Code;
-        readonly typeToJsonExpression: (valueVariable: Code) => Code;
         readonly unwrap: (instance: Code) => Code;
         readonly wrap: (instance: Code) => Code;
     }