@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/generators/ts/LiteralType.js

@@ -1,5 +1,13 @@
+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 { xsd } from "@tpluscode/rdf-ns-builders";
+import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
+import { Type } from "./Type.js";
 export class LiteralType extends TermType {
     languageIn;
     constructor({ languageIn, ...superParameters }) {
@@ -10,10 +18,10 @@ export class LiteralType extends TermType {
         this.languageIn = languageIn;
     }
     get jsonName() {
-        return '{ readonly "@language": string | undefined, readonly "@type": string | undefined, readonly "@value": string }';
+        return new Type.JsonName('{ readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string }');
     }
     fromJsonExpression({ variables, }) {
-        return `${this.dataFactoryVariable}.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+        return `dataFactory.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
     }
     hashStatements({ depth, variables, }) {
         return [
@@ -44,4 +52,7 @@ export class LiteralType extends TermType {
 })`;
     }
 }
+__decorate([
+    Memoize()
+], LiteralType.prototype, "jsonName", null);
 //# sourceMappingURL=LiteralType.js.map

package/dist/generators/ts/NumberType.d.ts

@@ -1,7 +1,8 @@
 import { PrimitiveType } from "./PrimitiveType.js";
 import type { Type } from "./Type.js";
-export declare class NumberType extends PrimitiveType<number> {
+export declare abstract class NumberType extends PrimitiveType<number> {
     readonly kind = "NumberType";
+    readonly typeof = "number";
     get conversions(): readonly Type.Conversion[];
     get name(): string;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;

package/dist/generators/ts/NumberType.js

@@ -9,6 +9,7 @@ import { PrimitiveType } from "./PrimitiveType.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class NumberType extends PrimitiveType {
     kind = "NumberType";
+    typeof = "number";
     get conversions() {
         const conversions = [
             {
@@ -30,7 +31,7 @@ export class NumberType extends PrimitiveType {
         if (this.primitiveIn.length > 0) {
             return this.primitiveIn.map((value) => value.toString()).join(" | ");
         }
-        return "number";
+        return this.typeof;
     }
     jsonZodSchema({ variables, }) {
         switch (this.primitiveIn.length) {
@@ -45,7 +46,8 @@ export class NumberType extends PrimitiveType {
     propertyFromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toNumber()`;
         if (this.primitiveIn.length > 0) {
-            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case ${value}:`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
+            const eitherTypeParameters = `<Error, ${this.name}>`;
+            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case ${value}:`).join(" ")} return purify.Either.of${eitherTypeParameters}(value); default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
         }
         return expression;
     }
@@ -55,6 +57,9 @@ export class NumberType extends PrimitiveType {
             .orDefault(variables.value);
     }
 }
+__decorate([
+    Memoize()
+], NumberType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], NumberType.prototype, "name", null);

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

@@ -1,44 +1,47 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
+import * as _ObjectType from "./_ObjectType/index.js";
+import type { IdentifierMintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import { Import } from "./Import.js";
-import type { Type } from "./Type.js";
-import * as _ObjectType from "./_ObjectType/index.js";
+import { Type } from "./Type.js";
 export declare class ObjectType extends DeclaredType {
-    readonly abstract: boolean;
-    readonly declarationType: TsObjectDeclarationType;
-    readonly kind = "ObjectType";
+    private readonly imports;
     protected readonly comment: Maybe<string>;
-    protected readonly extern: boolean;
-    protected readonly fromRdfType: Maybe<NamedNode>;
-    protected readonly label: Maybe<string>;
     protected readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+    protected readonly label: Maybe<string>;
     protected readonly toRdfTypes: readonly NamedNode[];
-    private readonly imports;
-    private readonly lazyAncestorObjectTypes;
-    private readonly lazyDescendantObjectTypes;
-    private readonly lazyParentObjectTypes;
-    private readonly lazyProperties;
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
+    readonly abstract: boolean;
+    readonly declarationType: TsObjectDeclarationType;
+    readonly extern: boolean;
+    readonly fromRdfType: Maybe<NamedNode>;
+    readonly kind = "ObjectType";
+    readonly staticModuleName: string;
+    readonly synthetic: boolean;
+    readonly typeof = "object";
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, identifierMintingStrategy, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         imports: readonly string[];
         label: Maybe<string>;
         lazyAncestorObjectTypes: () => readonly ObjectType[];
+        lazyChildObjectTypes: () => readonly ObjectType[];
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
-        lazyProperties: () => readonly ObjectType.Property[];
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
+        staticModuleName: string;
+        synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof DeclaredType>[0]);
     get _discriminatorProperty(): Type.DiscriminatorProperty;
     get ancestorObjectTypes(): readonly ObjectType[];
+    get childObjectTypes(): readonly ObjectType[];
     get conversions(): readonly Type.Conversion[];
     get declarationImports(): readonly Import[];
     get declarations(): (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
@@ -46,52 +49,72 @@ export declare class ObjectType extends DeclaredType {
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get discriminatorValue(): string;
     get equalsFunction(): string;
-    get hashFunctionName(): string;
-    get hashShaclPropertiesFunctionName(): string;
+    get fromRdfTypeVariable(): Maybe<string>;
+    get graphqlName(): Type.GraphqlName;
     get identifierProperty(): ObjectType.IdentifierProperty;
     get identifierType(): IdentifierType;
-    get jsonName(): string;
-    get jsonUiSchemaFunctionName(): string;
-    get jsonZodSchemaFunctionName(): string;
+    get identifierTypeAlias(): string;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
+    newExpression({ parameters }: {
+        parameters: string;
+    }): string;
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get ownProperties(): readonly ObjectType.Property[];
     get ownShaclProperties(): readonly ObjectType.Property[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
+    get toRdfjsResourceType(): string;
     protected get thisVariable(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement({ variables, }: {
+    fromJsonExpression({ variables, }: Parameters<DeclaredType["fromJsonExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<DeclaredType["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression({ variables, }: {
         variables: {
-            scopePrefix: string;
+            value: string;
         };
-    }): Maybe<string>;
-    jsonZodSchema(_parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    rdfjsResourceType(options?: {
-        mutable?: boolean;
-    }): {
-        readonly mutable: boolean;
-        readonly name: string;
-        readonly named: boolean;
-    };
-    snippetDeclarations(): readonly string[];
-    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(_features: Set<TsFeature>): readonly Import[];
+    }): string;
+    hashStatements({ variables, }: Parameters<DeclaredType["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<DeclaredType["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema({ context, variables, }: Parameters<DeclaredType["jsonZodSchema"]>[0]): ReturnType<DeclaredType["jsonZodSchema"]>;
+    snippetDeclarations({ recursionStack, }: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<DeclaredType["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<DeclaredType["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<DeclaredType["toJsonExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<DeclaredType["toRdfExpression"]>[0]): string;
+    useImports(): readonly Import[];
     protected ensureAtMostOneSuperObjectType(): void;
+    private readonly lazyAncestorObjectTypes;
+    private readonly lazyChildObjectTypes;
+    private readonly lazyDescendantObjectTypes;
+    private readonly lazyParentObjectTypes;
+    private readonly lazyProperties;
 }
 export declare namespace ObjectType {
+    const EagerShaclProperty: typeof _ObjectType.EagerShaclProperty;
+    type EagerShaclProperty<TypeT extends Type = Type> = _ObjectType.EagerShaclProperty<TypeT>;
     const IdentifierPrefixProperty: typeof _ObjectType.IdentifierPrefixProperty;
     type IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
     const IdentifierProperty: typeof _ObjectType.IdentifierProperty;
     type IdentifierProperty = _ObjectType.IdentifierProperty;
+    const LazyShaclProperty: typeof _ObjectType.LazyShaclProperty;
+    type LazyShaclProperty<LazyTypeT extends _ObjectType.LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>, ResolvedTypeT extends _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends _ObjectType.LazyShaclProperty.Type.StubTypeConstraint> = _ObjectType.LazyShaclProperty<LazyTypeT, ResolvedTypeT, StubTypeT>;
+    namespace LazyShaclProperty {
+        type Type<ResolvedTypeT extends _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends _ObjectType.LazyShaclProperty.Type.StubTypeConstraint> = _ObjectType.LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>;
+        namespace Type {
+            type ResolvedTypeConstraint = _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint;
+            type StubTypeConstraint = _ObjectType.LazyShaclProperty.Type.StubTypeConstraint;
+        }
+    }
+    type ObjectSetMethodNames = {
+        readonly object: string;
+        readonly objectsCount: string;
+        readonly objectIdentifiers: string;
+        readonly objects: string;
+    };
     const Property: typeof _ObjectType.Property;
     type Property = _ObjectType.Property<any>;
     const ShaclProperty: typeof _ObjectType.ShaclProperty;
-    type ShaclProperty = _ObjectType.ShaclProperty;
+    type ShaclProperty<TypeT extends Type> = _ObjectType.ShaclProperty<TypeT>;
     const TypeDiscriminatorProperty: typeof _ObjectType.TypeDiscriminatorProperty;
     type TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;
 }