@shaclmate/compiler 4.0.24 → 4.0.25

package/dist/generators/ts/NamedObjectUnionType.js

@@ -30,13 +30,13 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         return new AbstractType.GraphqlType(code `${this._name}.${syntheticNamePrefix}GraphQL`);
     }
     get identifierTypeAlias() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+        return code `${this.name}.${syntheticNamePrefix}Identifier`;
     }
     get objectSetMethodNames() {
         return NamedObjectType_objectSetMethodNames.call(this);
     }
     get schema() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+        return code `${this.name}.${syntheticNamePrefix}schema`;
     }
     get schemaType() {
         return code `typeof ${this.schema}`;
@@ -66,7 +66,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         }
         return singleEntryRecord(`${syntheticNamePrefix}focusSparqlConstructTriples`, code `\
 export function ${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
-  return [${joinCode(this.concreteMembers.map((member) => code `...${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.name}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
@@ -89,8 +89,8 @@ if (focusIdentifier.termType === "Variable") {
       variablePrefix,
   }));
 }`,
-            code `patterns.push({ patterns: [${joinCode(this.concreteMembers.map((member) => code `${{
-                patterns: code `${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+            code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
+                patterns: code `${member.type.name}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -103,8 +103,8 @@ if (focusIdentifier.termType === "Variable") {
         }
         return singleEntryRecord(`${syntheticNamePrefix}fromRdfResource`, code `\
 export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
-  ${this.concreteMembers.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.staticModuleName}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+  ${this.members.reduce((expression, member) => {
+            const memberTypeExpression = code `(${member.type.name}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -119,7 +119,7 @@ export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
             name: this.name,
             resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
-            types: code `[${joinCode(this.concreteMembers.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
+            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
         }});`);
     }
     get identifierTypeDeclarations() {
@@ -136,12 +136,12 @@ export namespace ${syntheticNamePrefix}Identifier {
         }
         return singleEntryRecord(`is${this._name}`, code `\
     export function is${this._name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
-      return ${joinCode(this.concreteMembers.map((member) => code `${member.type.staticModuleName}.is${member.type.name}(object)`), { on: " || " })};
+      return ${joinCode(this.members.map((member) => code `${member.type.name}.is${member.type.name}(object)`), { on: " || " })};
     }`);
     }
     get schemaVariableStatement() {
         const commonPropertiesByName = {};
-        this.concreteMembers.forEach((member, memberI) => {
+        this.members.forEach((member, memberI) => {
             for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
                 if (memberTypeProperty.kind !== "ShaclProperty") {
                     continue;
@@ -154,7 +154,7 @@ export namespace ${syntheticNamePrefix}Identifier {
                 }
                 else {
                     commonPropertiesByName[memberTypeProperty.name] = commonProperty = {
-                        memberTypesWithProperty: new Array(this.concreteMembers.length).fill(false),
+                        memberTypesWithProperty: new Array(this.members.length).fill(false),
                         property: memberTypeProperty,
                     };
                     commonProperty.memberTypesWithProperty[memberI] = true;
@@ -182,19 +182,8 @@ ${{
         }
         return singleEntryRecord(`${syntheticNamePrefix}toRdfResource`, code `\
 export const ${syntheticNamePrefix}toRdfResource: ${snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
-${joinCode(this.concreteMembers
-            .map((member) => {
-            let returnExpression;
-            switch (member.type.declarationType) {
-                case "class":
-                    returnExpression = code `value.${syntheticNamePrefix}toRdfResource(options)`;
-                    break;
-                case "interface":
-                    returnExpression = code `${member.type.staticModuleName}.${syntheticNamePrefix}toRdfResource(value, options)`;
-                    break;
-            }
-            return code `if (${member.type.staticModuleName}.is${member.type.name}(value)) { return ${returnExpression}; }`;
-        })
+${joinCode(this.members
+            .map((member) => code `if (${member.type.name}.is${member.type.name}(value)) { return ${member.type.name}.${syntheticNamePrefix}toRdfResource(value, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }

package/dist/generators/ts/TypeFactory.js

@@ -75,11 +75,8 @@ export class TypeFactory {
         const name = tsName(astType.name.unsafeCoerce(), {
             synthetic: astType.synthetic,
         });
-        const staticModuleName = astType.childObjectTypes.length > 0 ? `${name}Static` : name;
         const namedObjectType = new NamedObjectType({
-            abstract: astType.abstract,
             comment: astType.comment,
-            declarationType: astType.tsObjectDeclarationType,
             extern: astType.extern,
             features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
@@ -91,14 +88,9 @@ export class TypeFactory {
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createNamedObjectType(astType)),
             lazyDiscriminantProperty: (namedObjectType) => {
                 // Discriminant property
-                const discriminantOwnValue = !astType.abstract
-                    ? namedObjectType.discriminantValue
-                    : undefined;
                 const discriminantDescendantValues = new Set();
                 for (const descendantObjectType of namedObjectType.descendantObjectTypes) {
-                    if (!descendantObjectType.abstract) {
-                        discriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                    }
+                    discriminantDescendantValues.add(descendantObjectType.discriminantValue);
                 }
                 return new NamedObjectType.DiscriminantProperty({
                     logger: this.logger,
@@ -107,9 +99,8 @@ export class TypeFactory {
                     type: new NamedObjectType.DiscriminantProperty.Type({
                         descendantValues: [...discriminantDescendantValues].sort(),
                         mutable: false,
-                        ownValues: discriminantOwnValue ? [discriminantOwnValue] : [],
+                        ownValues: [namedObjectType.discriminantValue],
                     }),
-                    visibility: "public",
                 });
             },
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
@@ -128,27 +119,19 @@ export class TypeFactory {
                     astObjectTypeProperty: astProperty,
                     namedObjectType,
                 }));
-                if (namedObjectType._discriminantProperty.type.ownValues.length > 0 ||
-                    namedObjectType._discriminantProperty.type.descendantValues.length > 0) {
-                    properties.splice(0, 0, namedObjectType._discriminantProperty);
-                }
-                if (namedObjectType.declarationType === "interface" ||
-                    namedObjectType.parentObjectTypes.length === 0) {
-                    properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
-                        logger: this.logger,
-                        name: `${syntheticNamePrefix}identifier`,
-                        namedObjectType,
-                        type: identifierType,
-                        typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
-                        visibility: "public",
-                    }));
-                }
+                properties.splice(0, 0, namedObjectType._discriminantProperty);
+                properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
+                    logger: this.logger,
+                    name: `${syntheticNamePrefix}identifier`,
+                    namedObjectType,
+                    type: identifierType,
+                    typeAlias: code `${name}.${syntheticNamePrefix}Identifier`,
+                }));
                 return properties;
             },
             logger: this.logger,
             name,
             recursive: astType.recursive,
-            staticModuleName,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
@@ -442,7 +425,6 @@ export class TypeFactory {
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
             type: this.createType(astObjectTypeProperty.type),
-            visibility: astObjectTypeProperty.visibility,
         });
         this.cachedObjectTypePropertiesByShapeIdentifier.set(astObjectTypeProperty.shapeIdentifier, property);
         return property;

package/dist/generators/ts/ZodGenerator.js

@@ -15,7 +15,7 @@ export class ZodGenerator {
         const declarations = [];
         for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {
             declarations.push(code `\
-export namespace ${namedObjectType.staticModuleName} {
+export namespace ${namedObjectType.name} {
   ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.bind(namedObjectType)().toList())}
 
   export namespace ${syntheticNamePrefix}Json {
@@ -26,7 +26,7 @@ export namespace ${namedObjectType.staticModuleName} {
         for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => this.typeFactory.createUnionType(astNamedUnionType))) {
             invariant(astNamedUnionType.kind !== "AnonymousUnionType");
             declarations.push(code `\
-export namespace ${astNamedUnionType.staticModuleName} {
+export namespace ${astNamedUnionType.name} {
   ${astNamedUnionType.jsonTypeAliasDeclaration}
   export namespace ${syntheticNamePrefix}Json {
     ${astNamedUnionType.jsonSchemaFunctionDeclaration}

package/dist/generators/ts/_NamedObjectType/AbstractProperty.d.ts

@@ -1,6 +1,5 @@
 import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { Visibility } from "../../../enums/Visibility.js";
 import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
@@ -65,16 +64,11 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property type
   .   */
     readonly type: TypeT;
-    /**
-     * Property visibility: private, protected, public.
-     */
-    readonly visibility: Visibility;
-    constructor({ logger, name, namedObjectType, type, visibility, }: {
+    constructor({ logger, name, namedObjectType, type, }: {
         logger: Logger;
         name: string;
         namedObjectType: NamedObjectType;
         type: TypeT;
-        visibility: Visibility;
     });
     /**
      * TypeScript object describing this type, for runtime use.

package/dist/generators/ts/_NamedObjectType/AbstractProperty.js

@@ -19,16 +19,11 @@ export class AbstractProperty {
      * Property type
   .   */
     type;
-    /**
-     * Property visibility: private, protected, public.
-     */
-    visibility;
-    constructor({ logger, name, namedObjectType, type, visibility, }) {
+    constructor({ logger, name, namedObjectType, type, }) {
         this.logger = logger;
         this.name = name;
         this.namedObjectType = namedObjectType;
         this.type = type;
-        this.visibility = visibility;
     }
     /**
      * TypeScript object describing this type, for runtime use.

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.d.ts

@@ -14,7 +14,6 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     get declaration(): Code;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    private get abstract();
     private get initializer();
     private get override();
     constructorStatements(): readonly Code[];

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.js

@@ -5,7 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { imports } from "../imports.js";
 import { removeUndefined } from "../removeUndefined.js";
@@ -20,18 +19,9 @@ export class DiscriminantProperty extends AbstractProperty {
     recursive = false;
     constructor({ type, ...superParameters }) {
         super({ ...superParameters, type });
-        invariant(this.visibility === "public");
     }
     get declaration() {
-        switch (this.namedObjectType.declarationType) {
-            case "class":
-                return code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`;
-            case "interface":
-                return code `readonly ${this.name}: ${this.type.name};`;
-            default:
-                this.namedObjectType.declarationType;
-                throw new Error("should never reach this point");
-        }
+        return code `readonly ${this.name}: ${this.type.name};`;
     }
     get jsonSchema() {
         if (this.override) {
@@ -50,9 +40,6 @@ export class DiscriminantProperty extends AbstractProperty {
         }
         return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
     }
-    get abstract() {
-        return this.namedObjectType.abstract;
-    }
     get initializer() {
         return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
     }
@@ -60,27 +47,13 @@ export class DiscriminantProperty extends AbstractProperty {
         return this.namedObjectType.parentObjectTypes.length > 0;
     }
     constructorStatements() {
-        switch (this.namedObjectType.declarationType) {
-            case "class":
-                return [];
-            case "interface":
-                if (this.abstract) {
-                    return [];
-                }
-                return [code `const ${this.name} = ${this.initializer};`];
-        }
+        return [code `const ${this.name} = ${this.initializer};`];
     }
     fromJsonStatements() {
-        return !this.abstract &&
-            this.namedObjectType.declarationType === "interface"
-            ? [code `const ${this.name} = ${this.initializer};`]
-            : [];
+        return [code `const ${this.name} = ${this.initializer};`];
     }
     fromRdfResourceValuesExpression() {
-        return !this.abstract &&
-            this.namedObjectType.declarationType === "interface"
-            ? Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`)
-            : Maybe.empty();
+        return Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`);
     }
     hashStatements({ variables, }) {
         if (this.override) {

package/dist/generators/ts/_NamedObjectType/IdentifierProperty.js

@@ -22,7 +22,6 @@ export class IdentifierProperty extends AbstractProperty {
     recursive = false;
     constructor({ typeAlias, ...superParameters }) {
         super(superParameters);
-        invariant(this.visibility === "public");
         this.typeAlias = typeAlias;
     }
     get constructorParametersSignature() {
@@ -80,36 +79,26 @@ export class IdentifierProperty extends AbstractProperty {
         return code `${variables.object}.${this.name}()`;
     }
     constructorStatements({ variables, }) {
-        let lhs;
         const parameterVariable = code `${this.name}Parameter`;
         const statements = [
             // Pull out the parameter so the function can capture it if necessary.
             code `const ${parameterVariable} = ${variables.parameter};`,
+            code `let ${this.name}: () => ${this.typeAlias};`,
         ];
         const typeConversions = this.type.conversions;
-        switch (this.namedObjectType.declarationType) {
-            case "class": {
-                lhs = `this.${this.name}`;
-                break;
-            }
-            case "interface":
-                lhs = this.name;
-                statements.push(code `let ${this.name}: () => ${this.typeAlias};`);
-                break;
-        }
         const conversionBranches = [
-            code `if (typeof ${parameterVariable} === "function") { ${lhs} = ${parameterVariable}; }`,
+            code `if (typeof ${parameterVariable} === "function") { ${this.name} = ${parameterVariable}; }`,
         ];
         for (const conversion of typeConversions) {
             invariant(conversion.sourceTypeof !== "function");
             invariant(conversion.sourceTypeof !== "undefined");
-            conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(parameterVariable)}) { ${lhs} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
+            conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(parameterVariable)}) { ${this.name} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
         }
         if (this.type.nodeKinds.has("BlankNode")) {
-            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${imports.dataFactory}.blankNode(); ${lhs} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
+            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${imports.dataFactory}.blankNode(); ${this.name} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
         }
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        conversionBranches.push(code `{ ${lhs} = (${parameterVariable}) satisfies never;\n }`);
+        conversionBranches.push(code `{ ${this.name} = (${parameterVariable}) satisfies never;\n }`);
         statements.push(joinCode(conversionBranches, { on: " else " }));
         return statements;
     }
@@ -146,7 +135,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.type()`,
+                schema: code `${this.namedObjectType.name}.${syntheticNamePrefix}schema.properties.${this.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_createFunctionDeclaration.js

@@ -12,7 +12,7 @@ export function NamedObjectType_createFunctionDeclaration() {
         parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`);
+        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.${syntheticNamePrefix}create>[0]`);
     }
     if (parametersType.length === 0) {
         parametersType.push(code `object`);
@@ -21,7 +21,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
+        propertyInitializers.push(`...${parentObjectType.name}.${syntheticNamePrefix}create(parameters)`);
     }
     const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
         parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_equalsFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_equalsFunctionDeclaration.d.ts.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js

@@ -0,0 +1,25 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function NamedObjectType_equalsFunctionDeclaration() {
+    if (!this.features.has("equals")) {
+        return Maybe.empty();
+    }
+    const chain = [];
+    // For every parent, find the nearest equals implementation
+    for (const parentObjectType of this.parentObjectTypes) {
+        chain.push(code `${parentObjectType.name}.${syntheticNamePrefix}equals(left, right)`);
+    }
+    for (const property of this.properties) {
+        if (property.kind === "DiscriminantProperty") {
+            continue;
+        }
+        chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}equals(left: ${this.name}, right: ${this.name}): ${snippets.EqualsResult} {
+  return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
+}`);
+}
+//# sourceMappingURL=NamedObjectType_equalsFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterTypeDeclaration.js

@@ -14,7 +14,7 @@ export function NamedObjectType_filterTypeDeclaration() {
         }
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Filter`);
+        members.push(code `${parentObjectType.name}.${syntheticNamePrefix}Filter`);
     }
     return code `\
 export type ${syntheticNamePrefix}Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js

@@ -19,7 +19,7 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -21,7 +21,7 @@ export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `\
-patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js

@@ -5,12 +5,9 @@ export function NamedObjectType_fromJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
     return Maybe.of(code `\
 export function ${syntheticNamePrefix}fromJson(json: ${this.jsonType().name}): ${this.name} {
-  return ${this.newExpression({ parameters: code `${syntheticNamePrefix}propertiesFromJson(json)` })};
+  return ${syntheticNamePrefix}create(${syntheticNamePrefix}propertiesFromJson(json));
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js

@@ -6,15 +6,12 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
 ${joinCode([
         code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
         code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-        code `return ${code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(${this.declarationType === "interface" ? code `${syntheticNamePrefix}create` : code `properties => ${this.newExpression({ parameters: code `properties` })}`})`};`,
+        code `return ${code `${this.name}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(${syntheticNamePrefix}create)`};`,
     ])}
 };`);
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js

@@ -6,14 +6,11 @@ export function NamedObjectType_fromRdfResourceValuesFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
   values.chain(
     values => values.chainMap(
-      value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdfResource(resource, options))
+      value => value.toResource().chain(resource => ${this.name}.${syntheticNamePrefix}fromRdfResource(resource, options))
     )
   );`);
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_hashFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_hashFunctionDeclarations(this: NamedObjectType): readonly Code[];
+//# sourceMappingURL=NamedObjectType_hashFunctionDeclarations.d.ts.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_hashFunctionDeclarations.js

@@ -0,0 +1,49 @@
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const hasherVariable = code `_hasher`;
+export function NamedObjectType_hashFunctionDeclarations() {
+    if (!this.features.has("hash")) {
+        return [];
+    }
+    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
+        ? property.hashStatements({
+            depth: 0,
+            variables: {
+                hasher: hasherVariable,
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
+        })
+        : []);
+    const hashShaclPropertiesStatements = [];
+    const hashStatements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    }
+    hashStatements.push(code `${this.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
+    hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
+    hashStatements.push(...this.properties
+        .filter((property) => property.kind !== "ShaclProperty")
+        .flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
+        },
+    })));
+    hashStatements.push(code `return ${hasherVariable};`);
+    return [
+        code `\
+export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+  ${joinCode(hashStatements)}
+}`,
+        code `\
+export function ${syntheticNamePrefix}hashShaclProperties<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+  ${joinCode(hashShaclPropertiesStatements)}
+}`,
+    ];
+}
+//# sourceMappingURL=NamedObjectType_hashFunctionDeclarations.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js

@@ -6,9 +6,6 @@ export function NamedObjectType_jsonParseFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
     return Maybe.of(code `\
 export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
   const jsonSafeParseResult = schema().safeParse(json);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js

@@ -16,7 +16,7 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
             .map(({ key, schema }) => code `"${key}": ${schema}`));
     }
     const meta = {
-        id: this.name,
+    // id: this.name,
     };
     this.comment.ifJust((description) => {
         meta["description"] = description;

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js

@@ -7,7 +7,7 @@ export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.name}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
         .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js

@@ -13,8 +13,8 @@ export function NamedObjectType_propertiesFromJsonFunctionDeclaration() {
     const propertyReturnTypeSignatures = [];
     const returnType = [];
     this.parentObjectTypes.forEach((parentObjectType) => {
-        initializers.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject})`);
-        returnType.push(code `ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson>`);
+        initializers.push(code `...${parentObjectType.name}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject})`);
+        returnType.push(code `ReturnType<typeof ${parentObjectType.name}.${syntheticNamePrefix}propertiesFromJson>`);
     });
     for (const property of this.properties) {
         const propertyFromJsonStatements = property.fromJsonStatements({

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js

@@ -24,11 +24,11 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     const returnType = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
-            expression: code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
+            expression: code `${parentObjectType.name}.${syntheticNamePrefix}propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
             variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
         });
         initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource>>`);
+        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.name}.${syntheticNamePrefix}propertiesFromRdfResource>>`);
     });
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();