@shaclmate/compiler 4.0.23 → 4.0.25

package/dist/ast/ObjectType.d.ts

@@ -2,10 +2,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { PropertyPath } from "@rdfx/resource";
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
-import type { TsFeature } from "../enums/TsFeature.js";
-import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
-import type { Visibility } from "../enums/Visibility.js";
+import type { TsFeature } from "../generators/ts/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -13,12 +10,6 @@ import type { IriType } from "./IriType.js";
 import { Type } from "./Type.js";
 export declare class ObjectType extends AbstractType {
     #private;
-    /**
-     * Classes generated from this type are abstract / cannot be instantiated themselves.
-     *
-     * Defaults to false.
-     */
-    readonly abstract: boolean;
     /**
      * If true, the code for this ObjectType is defined externally and should not be generated.
      *
@@ -32,10 +23,6 @@ export declare class ObjectType extends AbstractType {
      * class targets).
      */
     readonly fromRdfType: Maybe<NamedNode>;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * Identifier type.
      */
@@ -69,21 +56,14 @@ export declare class ObjectType extends AbstractType {
      * import { MyType } from "./MyType.js"
      */
     readonly tsImports: readonly string[];
-    /**
-     * Whether to generate a TypeScript class or interface for this type.
-     */
-    readonly tsObjectDeclarationType: TsObjectDeclarationType;
-    constructor({ abstract, extern, fromRdfType, identifierMintingStrategy, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
-        abstract: boolean;
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, ...superParameters }: {
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
         tsFeatures: ReadonlySet<TsFeature>;
         tsImports: readonly string[];
-        tsObjectDeclarationType: TsObjectDeclarationType;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get ancestorObjectTypes(): readonly ObjectType[];
     get childObjectTypes(): readonly ObjectType[];
@@ -100,7 +80,6 @@ export declare class ObjectType extends AbstractType {
     sortProperties(): void;
     toJSON(): {
         fromRdfType: NamedNode<string> | undefined;
-        identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
         identifierType: {
             hasValues: readonly NamedNode<string>[] | undefined;
             in: readonly NamedNode<string>[] | undefined;
@@ -170,11 +149,7 @@ export declare namespace ObjectType {
          * Type of this property.
          */
         readonly type: Type;
-        /**
-         * Visibility: private, protected, public.
-         */
-        readonly visibility: Visibility;
-        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }: {
+        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, }: {
             comment: Maybe<string>;
             description: Maybe<string>;
             display: boolean;
@@ -186,7 +161,6 @@ export declare namespace ObjectType {
             path: PropertyPath;
             shapeIdentifier: BlankNode | NamedNode;
             type: Type;
-            visibility: Visibility;
         });
         equals(other: Property): boolean;
         /**
@@ -211,7 +185,6 @@ export declare namespace ObjectType {
                 recursive: boolean | undefined;
                 shapeIdentifier: BlankNode | NamedNode<string>;
             };
-            visibility: Visibility;
         };
         toString(): string;
     }

package/dist/ast/ObjectType.js

@@ -43,12 +43,6 @@ export class ObjectType extends AbstractType {
      * Mutable to support cycle-handling logic in the compiler.
      */
     #properties = [];
-    /**
-     * Classes generated from this type are abstract / cannot be instantiated themselves.
-     *
-     * Defaults to false.
-     */
-    abstract;
     /**
      * If true, the code for this ObjectType is defined externally and should not be generated.
      *
@@ -62,10 +56,6 @@ export class ObjectType extends AbstractType {
      * class targets).
      */
     fromRdfType;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    identifierMintingStrategy;
     /**
      * Identifier type.
      */
@@ -99,22 +89,15 @@ export class ObjectType extends AbstractType {
      * import { MyType } from "./MyType.js"
      */
     tsImports;
-    /**
-     * Whether to generate a TypeScript class or interface for this type.
-     */
-    tsObjectDeclarationType;
-    constructor({ abstract, extern, fromRdfType, identifierMintingStrategy, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, ...superParameters }) {
         super(superParameters);
-        this.abstract = abstract;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
-        this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierType = identifierType;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
         this.tsFeatures = tsFeatures;
         this.tsImports = tsImports;
-        this.tsObjectDeclarationType = tsObjectDeclarationType;
     }
     get ancestorObjectTypes() {
         return this.#ancestorObjectTypes;
@@ -171,7 +154,6 @@ export class ObjectType extends AbstractType {
         return {
             ...super.toJSON(),
             fromRdfType: this.fromRdfType.extract(),
-            identifierMintingStrategy: this.identifierMintingStrategy.extract(),
             identifierType: this.identifierType.toJSON(),
             parentObjectTypes: this.parentObjectTypes.length > 0
                 ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??
@@ -230,11 +212,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          * Type of this property.
          */
         type;
-        /**
-         * Visibility: private, protected, public.
-         */
-        visibility;
-        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }) {
+        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, }) {
             this.comment = comment;
             this.description = description;
             this.display = display;
@@ -246,7 +224,6 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
             this.path = path;
             this.shapeIdentifier = shapeIdentifier;
             this.type = type;
-            this.visibility = visibility;
         }
         equals(other) {
             return this.shapeIdentifier.equals(other.shapeIdentifier);
@@ -379,7 +356,6 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                 recursive: this.recursive ? true : undefined,
                 shapeIdentifier: this.shapeIdentifier,
                 type: this.type.toJSON(),
-                visibility: this.visibility,
             };
         }
         toString() {

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

@@ -24,7 +24,6 @@ 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 abstract = false;
     readonly declaration: Maybe<Code>;
     abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
     /**

package/dist/generators/ts/AbstractContainerType.js

@@ -13,7 +13,6 @@ 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 {
-    abstract = false;
     declaration = Maybe.empty();
     /**
      * Container item type.

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -13,7 +13,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
-    readonly abstract = false;
     readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -9,12 +9,12 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractLazyObjectType extends AbstractType {
     partialType;
     resolveType;
     runtimeClass;
-    abstract = false;
     declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
@@ -124,7 +124,7 @@ export class AbstractLazyObjectType extends AbstractType {
         invariant(resolvedNamedObjectUnionType.members.length ===
             partialNamedObjectUnionType.members.length);
         const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.newExpression({ parameters: variables.resolvedObjectUnion })};`;
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.${syntheticNamePrefix}create(${variables.resolvedObjectUnion});`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import { AbstractUnionType } from "./AbstractUnionType.js";
+import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
@@ -18,7 +18,6 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     get jsonSchemaFunctionDeclaration(): Code;
     get jsonTypeAliasDeclaration(): Code;
     get name(): string;
-    get staticModuleName(): string;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get staticModuleDeclarations(): Record<string, Code>;

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -27,7 +27,7 @@ export class AbstractNamedUnionType extends AbstractUnionType {
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
-export namespace ${def(this.staticModuleName)} {
+export namespace ${def(this.name)} {
 ${joinCode(staticModuleDeclarations
                 .sort((left, right) => left[0].localeCompare(right[0]))
                 .map((_) => _[1]), { on: "\n\n" })}
@@ -37,19 +37,19 @@ ${joinCode(staticModuleDeclarations
     }
     get equalsFunction() {
         if (this.features.has("equals")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+            return code `${this.name}.${syntheticNamePrefix}equals`;
         }
         return this.inlineEqualsFunction;
     }
     get filterFunction() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
+        return code `${this.name}.${syntheticNamePrefix}filter`;
     }
     get filterType() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
+        return code `${this.name}.${syntheticNamePrefix}Filter`;
     }
     get jsonSchemaFunctionDeclaration() {
         const meta = {
-            id: this.name,
+        // id: this.name,
         };
         this.comment.ifJust((description) => {
             meta["description"] = description;
@@ -65,18 +65,15 @@ ${joinCode(staticModuleDeclarations
     get name() {
         return this._name;
     }
-    get staticModuleName() {
-        return this._name;
-    }
     get valueSparqlConstructTriplesFunction() {
         if (this.features.has("sparql")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+            return code `${this.name}.${syntheticNamePrefix}valueSparqlConstructTriples`;
         }
         return this.inlineValueSparqlConstructTriplesFunction;
     }
     get valueSparqlWherePatternsFunction() {
         if (this.features.has("sparql")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+            return code `${this.name}.${syntheticNamePrefix}valueSparqlWherePatterns`;
         }
         return this.inlineValueSparqlWherePatternsFunction;
     }
@@ -130,30 +127,30 @@ export namespace ${syntheticNamePrefix}Json {
     }
     fromJsonExpression({ variables, }) {
         if (this.features.has("json")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
+            return code `${this.name}.${syntheticNamePrefix}fromJson(${variables.value})`;
         }
         return code `${this.inlineFromJsonFunction}(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
         if (this.features.has("rdf")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+            return code `${this.name}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
         }
         return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
     }
     hashStatements({ depth, variables, }) {
         if (this.features.has("hash")) {
             return [
-                code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+                code `${this.name}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
             ];
         }
         return this.inlineHashStatements({ depth, variables });
     }
     jsonSchema({ context, }) {
         if (this.features.has("json")) {
-            const expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
+            const expression = code `${this.name}.${syntheticNamePrefix}Json.schema()`;
             if (context === "property" && this.recursive) {
-                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.name}.${syntheticNamePrefix}Json> => ${expression})`;
             }
             return expression;
         }
@@ -161,25 +158,25 @@ export namespace ${syntheticNamePrefix}Json {
     }
     jsonType() {
         if (this.features.has("json")) {
-            return new AbstractType.JsonType(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
+            return new AbstractType.JsonType(`${this.name}.${syntheticNamePrefix}Json`);
         }
         return this.inlineJsonType;
     }
     toJsonExpression({ variables, }) {
         if (this.features.has("json")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
+            return code `${this.name}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
         return code `${this.inlineToJsonFunction}(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const { value: valueVariable, ...otherVariables } = variables;
         if (this.features.has("rdf")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
+            return code `${this.name}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
         }
         return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
     }
     toStringExpression({ variables, }) {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}toString(${variables.value})`;
+        return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
     }
 }
 __decorate([

package/dist/generators/ts/AbstractTermType.d.ts

@@ -13,7 +13,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    readonly abstract = false;
     readonly declaration: Maybe<Code>;
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];

package/dist/generators/ts/AbstractTermType.js

@@ -22,7 +22,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export class AbstractTermType extends AbstractType {
-    abstract = false;
     declaration = Maybe.empty();
     equalsFunction = code `${snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();

package/dist/generators/ts/AbstractType.d.ts

@@ -7,10 +7,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractType {
     protected readonly logger: Logger;
-    /**
-     * Is the type abstract?
-     */
-    abstract readonly abstract: boolean;
     /**
      * Comment from rdfs:comment.
      */

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -9,7 +9,6 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
     private readonly identifierType;
-    readonly abstract = false;
     readonly recursive: boolean;
     constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
@@ -26,7 +25,6 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get typeofs(): AbstractType["typeofs"];
-    protected get concreteMembers(): readonly AbstractUnionType.ConcreteMember<MemberTypeT>[];
     protected get inlineEqualsFunction(): Code;
     protected get inlineFilterFunction(): Code;
     protected get inlineFilterType(): Code;
@@ -81,13 +79,7 @@ export declare namespace Discriminant {
     }[]): Discriminant;
 }
 export declare namespace AbstractUnionType {
-    interface AbstractMember<TypeT extends Type> {
-        readonly abstract: true;
-        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly type: TypeT;
-    }
-    interface ConcreteMember<TypeT extends Type> {
-        readonly abstract: false;
+    interface Member<TypeT extends Type> {
         readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
         readonly jsonType: Code | string;
         readonly jsonTypeCheck: (instance: Code) => Code;
@@ -98,7 +90,6 @@ export declare namespace AbstractUnionType {
         readonly unwrap: (instance: Code) => Code;
         readonly wrap: (instance: Code) => Code;
     }
-    type Member<TypeT extends Type> = AbstractMember<TypeT> | ConcreteMember<TypeT>;
 }
 export {};
 //# sourceMappingURL=AbstractUnionType.d.ts.map