@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/generators/ts/objectSetInterfaceDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function objectSetInterfaceDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): readonly (InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
+//# sourceMappingURL=objectSetInterfaceDeclaration.d.ts.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -0,0 +1,46 @@
+import { StructureKind, } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function objectSetInterfaceDeclaration({ objectTypes, objectUnionTypes, }) {
+    const typeParameters = {
+        ObjectIdentifierT: {
+            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
+            name: "ObjectIdentifierT",
+        },
+    };
+    return [
+        {
+            isExported: true,
+            kind: StructureKind.Interface,
+            methods: objectTypes
+                .flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })))
+                .concat(objectUnionTypes.flatMap((objectUnionType) => Object.values(objectSetMethodSignatures({ objectType: objectUnionType })))),
+            name: `${syntheticNamePrefix}ObjectSet`,
+        },
+        {
+            isExported: true,
+            kind: StructureKind.Module,
+            name: `${syntheticNamePrefix}ObjectSet`,
+            statements: [
+                {
+                    kind: StructureKind.TypeAlias,
+                    isExported: true,
+                    name: "Query",
+                    type: `{ readonly limit?: number; readonly offset?: number; readonly where?: Where<${typeParameters.ObjectIdentifierT.name}> }`,
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+                {
+                    kind: StructureKind.TypeAlias,
+                    isExported: true,
+                    name: "Where",
+                    type: [
+                        `{ readonly identifiers: readonly ${typeParameters.ObjectIdentifierT.name}[]; readonly type: "identifiers" } `,
+                        `{ readonly predicate: rdfjs.NamedNode; readonly subject: rdfjs.BlankNode | rdfjs.NamedNode; readonly type: "triple-objects" } `,
+                    ].join(" | "),
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=objectSetInterfaceDeclaration.js.map

package/dist/generators/ts/objectSetMethodSignatures.d.ts

@@ -0,0 +1,11 @@
+import type { MethodSignatureStructure, OptionalKind } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+export declare function objectSetMethodSignatures(parameters: {
+    objectType: {
+        readonly identifierTypeAlias: string;
+        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly name: string;
+    };
+    queryT?: string;
+}): Record<keyof ObjectType.ObjectSetMethodNames, OptionalKind<MethodSignatureStructure>>;
+//# sourceMappingURL=objectSetMethodSignatures.d.ts.map

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -0,0 +1,52 @@
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function objectSetMethodSignatures(parameters) {
+    const { objectType } = parameters;
+    const queryT = parameters.queryT ?? `${syntheticNamePrefix}ObjectSet.Query`;
+    const methodNames = objectType.objectSetMethodNames;
+    return {
+        object: {
+            name: methodNames.object,
+            parameters: [
+                {
+                    name: "identifier",
+                    type: objectType.identifierTypeAlias,
+                },
+            ],
+            returnType: `Promise<purify.Either<Error, ${objectType.name}>>`,
+        },
+        objectIdentifiers: {
+            name: methodNames.objectIdentifiers,
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: "query",
+                    type: `${queryT}<${objectType.identifierTypeAlias}>`,
+                },
+            ],
+            returnType: `Promise<purify.Either<Error, readonly ${objectType.identifierTypeAlias}[]>>`,
+        },
+        objects: {
+            name: methodNames.objects,
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: "query",
+                    type: `${queryT}<${objectType.identifierTypeAlias}>`,
+                },
+            ],
+            returnType: `Promise<purify.Either<Error, readonly ${objectType.name}[]>>`,
+        },
+        objectsCount: {
+            name: methodNames.objectsCount,
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: "query",
+                    type: `Pick<${queryT}<${objectType.identifierTypeAlias}>, "where">`,
+                },
+            ],
+            returnType: "Promise<purify.Either<Error, number>>",
+        },
+    };
+}
+//# sourceMappingURL=objectSetMethodSignatures.js.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type ClassDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): ClassDeclarationStructure;
+//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -0,0 +1,393 @@
+import { Scope, StructureKind, } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
+export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const typeParameters = {
+        ObjectT: {
+            constraint: "{ readonly $identifier: ObjectIdentifierT }",
+            name: "ObjectT",
+        },
+        ObjectIdentifierT: {
+            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
+            name: "ObjectIdentifierT",
+        },
+    };
+    const fromRdfFunctionType = `(parameters: { objectSet: ${syntheticNamePrefix}ObjectSet, resource: rdfjsResource.Resource }) => purify.Either<Error, ${typeParameters.ObjectT.name}>`;
+    const reusableMethodDeclarations = [];
+    if (objectTypes.length > 0) {
+        const parameters = {
+            objectType: {
+                name: "objectType",
+                type: `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`,
+            },
+            query: {
+                hasQuestionToken: true,
+                name: "query",
+                type: `${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
+            },
+        };
+        reusableMethodDeclarations.push({
+            kind: StructureKind.Method,
+            name: `${syntheticNamePrefix}objectIdentifiersSync`,
+            parameters: [parameters.objectType, parameters.query],
+            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>`,
+            scope: Scope.Protected,
+            statements: [
+                `\
+return this.${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectType.name}, ${parameters.query.name}).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));`,
+            ],
+            typeParameters: [
+                typeParameters.ObjectT,
+                typeParameters.ObjectIdentifierT,
+            ],
+        }, {
+            kind: StructureKind.Method,
+            name: `${syntheticNamePrefix}objectsSync`,
+            parameters: [parameters.objectType, parameters.query],
+            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>`,
+            scope: Scope.Protected,
+            statements: [
+                `\
+const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+if (limit <= 0) { return purify.Either.of([]); }
+
+let offset = query?.offset ?? 0;
+if (offset < 0) { offset = 0; }
+
+if (query?.where) {
+  // Assign identifiers in each case block so the compiler will catch missing cases.
+  let identifiers: rdfjsResource.Resource.Identifier[];
+  switch (query.where.type) {
+    case "identifiers": {
+      identifiers = query.where.identifiers.slice(offset, offset + limit);
+      break;
+    }
+    case "triple-objects": {
+      let identifierI = 0;
+      identifiers = [];
+      for (const quad of this.resourceSet.dataset.match(query.where.subject, query.where.predicate, null)) {
+        if (quad.object.termType === "BlankNode" || quad.object.termType === "NamedNode") {
+          if (++identifierI >= offset) {
+            identifiers.push(quad.object);
+            if (identifiers.length === limit) {
+              break;
+            }
+          }
+        } else {
+          return purify.Left(new Error(\`subject=\${query.where.subject.value} predicate=\${query.where.predicate.value} pattern matches non-identifier (\${quad.object.termType}) triple\`));
+        }
+      }
+      break;
+    }
+  }
+
+  const objects: ${typeParameters.ObjectT.name}[] = [];
+  for (const identifier of identifiers) {
+    const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource: this.resourceSet.resource(identifier) });
+    if (either.isLeft()) {
+      return either;
+    }
+    objects.push(either.unsafeCoerce());
+  }
+  return purify.Either.of(objects);
+}
+
+if (!objectType.${syntheticNamePrefix}fromRdfType) {
+  return purify.Either.of([]);
+}
+
+const resources = [...this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)];
+// Sort resources by identifier so limit and offset are deterministic
+resources.sort((left, right) => left.identifier.value.localeCompare(right.identifier.value));
+
+const objects: ${typeParameters.ObjectT.name}[] = [];
+let objectI = 0;
+for (const resource of resources) {
+  const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource });
+  if (either.isLeft()) {
+    return either;
+  }
+  if (objectI++ >= offset) {
+     objects.push(either.unsafeCoerce());
+     if (objects.length === limit) {
+      return purify.Either.of(objects);
+     }
+  }
+}
+return purify.Either.of(objects);
+`,
+            ],
+            typeParameters: [
+                typeParameters.ObjectT,
+                typeParameters.ObjectIdentifierT,
+            ],
+        }, {
+            kind: StructureKind.Method,
+            name: `${syntheticNamePrefix}objectsCountSync`,
+            parameters: [parameters.objectType, parameters.query],
+            returnType: "purify.Either<Error, number>",
+            scope: Scope.Protected,
+            statements: [
+                `return this.${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectType.name}, ${parameters.query.name}).map(objects => objects.length);`,
+            ],
+            typeParameters: [
+                typeParameters.ObjectT,
+                typeParameters.ObjectIdentifierT,
+            ],
+        });
+    }
+    if (objectUnionTypes.length > 0) {
+        const objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`;
+        const parameters = {
+            objectTypes: {
+                name: "objectTypes",
+                type: `readonly ${objectTypeType}[]`,
+            },
+            query: {
+                hasQuestionToken: true,
+                name: "query",
+                type: `${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
+            },
+        };
+        reusableMethodDeclarations.push({
+            kind: StructureKind.Method,
+            name: `${syntheticNamePrefix}objectUnionIdentifiersSync`,
+            parameters: [parameters.objectTypes, parameters.query],
+            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>`,
+            scope: Scope.Protected,
+            statements: [
+                `return this.${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectTypes.name}, ${parameters.query.name}).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));`,
+            ],
+            typeParameters: [
+                typeParameters.ObjectT,
+                typeParameters.ObjectIdentifierT,
+            ],
+        }, {
+            kind: StructureKind.Method,
+            name: `${syntheticNamePrefix}objectUnionsSync`,
+            parameters: [parameters.objectTypes, parameters.query],
+            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>`,
+            scope: Scope.Protected,
+            statements: [
+                `\
+const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+if (limit <= 0) { return purify.Either.of([]); }
+
+let offset = query?.offset ?? 0;
+if (offset < 0) { offset = 0; }
+
+if (query?.where) {
+  // Assign identifiers in each case block so the compiler will catch missing cases.
+  let identifiers: rdfjsResource.Resource.Identifier[];
+  switch (query.where.type) {
+    case "identifiers": {
+      identifiers = query.where.identifiers.slice(offset, offset + limit);
+      break;
+    }
+    case "triple-objects": {
+      let identifierI = 0;
+      identifiers = [];
+      for (const quad of this.resourceSet.dataset.match(query.where.subject, query.where.predicate, null)) {
+        if (quad.object.termType === "BlankNode" || quad.object.termType === "NamedNode") {
+          if (++identifierI >= offset) {
+            identifiers.push(quad.object);
+            if (identifiers.length === limit) {
+              break;
+            }
+          }
+        } else {
+          return purify.Left(new Error(\`subject=\${query.where.subject.value} predicate=\${query.where.predicate.value} pattern matches non-identifier (\${quad.object.termType}) triple\`));
+        }
+      }
+      break;
+    }
+  }
+
+  const objects: ${typeParameters.ObjectT.name}[] = [];
+  for (const identifier of identifiers) {
+    const resource = this.resourceSet.resource(identifier);
+    const lefts: purify.Either<Error, ${typeParameters.ObjectT.name}>[] = [];
+    for (const objectType of objectTypes) {
+      const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource });
+      if (either.isRight()) {
+        objects.push(either.unsafeCoerce());
+        break;
+      }
+      lefts.push(either);
+    }
+    // Doesn't appear to belong to any of the known object types, just assume the first
+    if (lefts.length === objectTypes.length) {
+      return lefts[0] as unknown as purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>;
+    }
+  }
+  return purify.Either.of(objects);
+}
+
+const resources: { objectType: ${objectTypeType}, resource: rdfjsResource.Resource }[] = [];
+for (const objectType of objectTypes) {
+  if (!objectType.${syntheticNamePrefix}fromRdfType) {
+    continue;
+  }
+
+  for (const resource of this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)) {
+    resources.push({ objectType, resource });
+  }
+}
+
+// Sort resources by identifier so limit and offset are deterministic
+resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
+
+let objectI = 0;
+const objects: ${typeParameters.ObjectT.name}[] = [];
+for (const { objectType, resource } of resources) {
+  const either = objectType.${syntheticNamePrefix}fromRdf({ objectSet: this, resource });
+  if (either.isLeft()) {
+    return either;
+  }
+  if (objectI++ >= offset) {
+    objects.push(either.unsafeCoerce());
+    if (objects.length === limit) {
+      return purify.Either.of(objects);
+    }
+  }
+}
+return purify.Either.of(objects);
+`,
+            ],
+            typeParameters: [
+                typeParameters.ObjectT,
+                typeParameters.ObjectIdentifierT,
+            ],
+        }, {
+            kind: StructureKind.Method,
+            name: `${syntheticNamePrefix}objectUnionsCountSync`,
+            parameters: [parameters.objectTypes, parameters.query],
+            returnType: "purify.Either<Error, number>",
+            statements: [
+                `return this.${syntheticNamePrefix}objectUnionIdentifiersSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectTypes.name}, ${parameters.query.name}).map(objects => objects.length);`,
+            ],
+            typeParameters: [
+                typeParameters.ObjectT,
+                typeParameters.ObjectIdentifierT,
+            ],
+            scope: Scope.Protected,
+        });
+    }
+    return {
+        ctors: [
+            {
+                parameters: [
+                    {
+                        name: "{ dataset }",
+                        type: "{ dataset: rdfjs.DatasetCore }",
+                    },
+                ],
+                statements: [
+                    "this.resourceSet = new rdfjsResource.ResourceSet({ dataset })",
+                ],
+            },
+        ],
+        implements: [`${syntheticNamePrefix}ObjectSet`],
+        isExported: true,
+        kind: StructureKind.Class,
+        name: `${syntheticNamePrefix}RdfjsDatasetObjectSet`,
+        methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
+            if (!objectType.features.has("rdf")) {
+                return unsupportedObjectSetMethodDeclarations({
+                    objectType,
+                });
+            }
+            const methodSignatures = objectSetMethodSignatures({ objectType });
+            let runtimeObjectType;
+            switch (objectType.kind) {
+                case "ObjectType":
+                    runtimeObjectType = objectType.fromRdfType.isJust()
+                        ? `${objectType.staticModuleName}`
+                        : `{ ...${objectType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`;
+                    break;
+                case "ObjectUnionType":
+                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => memberType.fromRdfType.isJust()
+                        ? `${memberType.staticModuleName}`
+                        : `{ ...${memberType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`)}]`;
+                    break;
+            }
+            return [
+                {
+                    ...methodSignatures.object,
+                    isAsync: true,
+                    kind: StructureKind.Method,
+                    statements: [
+                        `return this.${methodSignatures.object.name}Sync(identifier);`,
+                    ],
+                },
+                {
+                    ...methodSignatures.object,
+                    kind: StructureKind.Method,
+                    name: `${methodSignatures.object.name}Sync`,
+                    returnType: `purify.Either<Error, ${objectType.name}>`,
+                    statements: [
+                        `return this.${methodSignatures.objects.name}Sync({ where: { identifiers: [identifier], type: "identifiers" } }).map(objects => objects[0]);`,
+                    ],
+                },
+                {
+                    ...methodSignatures.objectIdentifiers,
+                    isAsync: true,
+                    kind: StructureKind.Method,
+                    statements: [
+                        `return this.${methodSignatures.objectIdentifiers.name}Sync(query);`,
+                    ],
+                },
+                {
+                    ...methodSignatures.objectIdentifiers,
+                    kind: StructureKind.Method,
+                    name: `${methodSignatures.objectIdentifiers.name}Sync`,
+                    returnType: `purify.Either<Error, readonly ${objectType.identifierTypeAlias}[]>`,
+                    statements: `return this.${syntheticNamePrefix}object${objectType.kind === "ObjectUnionType" ? "Union" : ""}IdentifiersSync<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                },
+                {
+                    ...methodSignatures.objects,
+                    isAsync: true,
+                    kind: StructureKind.Method,
+                    statements: [
+                        `return this.${methodSignatures.objects.name}Sync(query);`,
+                    ],
+                },
+                {
+                    ...methodSignatures.objects,
+                    kind: StructureKind.Method,
+                    name: `${methodSignatures.objects.name}Sync`,
+                    returnType: `purify.Either<Error, readonly ${objectType.name}[]>`,
+                    statements: [
+                        `return this.${syntheticNamePrefix}object${objectType.kind === "ObjectUnionType" ? "Union" : ""}sSync<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                    ],
+                },
+                {
+                    ...methodSignatures.objectsCount,
+                    isAsync: true,
+                    kind: StructureKind.Method,
+                    statements: [
+                        `return this.${methodSignatures.objectsCount.name}Sync(query);`,
+                    ],
+                },
+                {
+                    ...methodSignatures.objectsCount,
+                    kind: StructureKind.Method,
+                    name: `${methodSignatures.objectsCount.name}Sync`,
+                    returnType: "purify.Either<Error, number>",
+                    statements: [
+                        `return this.${syntheticNamePrefix}object${objectType.kind === "ObjectUnionType" ? "Union" : ""}sCountSync<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                    ],
+                },
+            ];
+        }).concat(reusableMethodDeclarations),
+        properties: [
+            {
+                isReadonly: true,
+                name: "resourceSet",
+                type: "rdfjsResource.ResourceSet",
+            },
+        ],
+    };
+}
+//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.js.map

package/dist/generators/ts/rdfjsTermExpression.d.ts

@@ -0,0 +1,3 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
+export declare function rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
+//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/dist/generators/ts/rdfjsTermExpression.js

@@ -0,0 +1,57 @@
+import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
+import { logger } from "../../logger.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function rdfjsTermExpression(rdfjsTerm) {
+    switch (rdfjsTerm.termType) {
+        case "BlankNode":
+            return `dataFactory.blankNode("${rdfjsTerm.value}")`;
+        case "Literal":
+            if (rdfjsTerm.datatype.equals(xsd.string)) {
+                if (rdfjsTerm.language.length === 0) {
+                    return `dataFactory.literal("${rdfjsTerm.value}")`;
+                }
+                return `dataFactory.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
+            }
+            return `dataFactory.literal("${rdfjsTerm.value}", ${rdfjsTermExpression(rdfjsTerm.datatype)})`;
+        case "NamedNode": {
+            if (rdfjsTerm.value.startsWith(rdf[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
+                switch (unqualifiedName) {
+                    case "first":
+                    case "nil":
+                    case "rest":
+                    case "subject":
+                    case "type":
+                        return `${syntheticNamePrefix}RdfVocabularies.rdf.${unqualifiedName}`;
+                    default:
+                        logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
+                }
+            }
+            else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
+                switch (unqualifiedName) {
+                    case "subClassOf":
+                        return `${syntheticNamePrefix}RdfVocabularies.rdfs.${unqualifiedName}`;
+                    default:
+                        logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
+                }
+            }
+            else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(xsd[""].value.length);
+                switch (unqualifiedName) {
+                    case "boolean":
+                    case "date":
+                    case "dateTime":
+                    case "integer":
+                        return `${syntheticNamePrefix}RdfVocabularies.xsd.${unqualifiedName}`;
+                    default:
+                        logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
+                }
+            }
+            return `dataFactory.namedNode("${rdfjsTerm.value}")`;
+        }
+        case "Variable":
+            return `dataFactory.variable!("${rdfjsTerm.value}")`;
+    }
+}
+//# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type ClassDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): readonly (ClassDeclarationStructure | ModuleDeclarationStructure)[];
+//# sourceMappingURL=sparqlObjectSetClassDeclaration.d.ts.map