@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/input/tsFeatures.d.ts

@@ -1,10 +1,11 @@
 import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { TsFeature } from "../enums/index.js";
-type TsFeatureIri = rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_FromJson" | "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql" | "http://purl.org/shaclmate/ontology#_TsFeature_ToJson" | "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf">;
+import type { TsFeature } from "../enums/index.js";
+type TsFeatureIri = rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">;
 export declare function tsFeatures(generated: {
     readonly tsFeatureExcludes: readonly TsFeatureIri[];
     readonly tsFeatureIncludes: readonly TsFeatureIri[];
 }): Maybe<Set<TsFeature>>;
+export declare const tsFeaturesDefault: readonly TsFeature[];
 export {};
 //# sourceMappingURL=tsFeatures.d.ts.map

package/dist/input/tsFeatures.js

@@ -1,50 +1,67 @@
 import { Maybe } from "purify-ts";
-import { TsFeature } from "../enums/index.js";
 function iriToTsFeatures(iri) {
     switch (iri.value) {
-        case "http://purl.org/shaclmate/ontology#_TsFeature_All":
-            return TsFeature.MEMBERS;
+        case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+            return tsFeaturesAll;
         case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
             return ["create"];
+        case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":
+            return tsFeaturesDefault;
         case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
             return ["equals"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_FromJson":
-            return ["fromJson"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf":
-            return ["fromRdf"];
+        case "http://purl.org/shaclmate/ontology#_TsFeature_Graphql":
+            return ["graphql"];
+        case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
+            return ["json"];
+        case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
+            return ["rdf"];
         case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
             return ["hash"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
-            return ["fromJson", "jsonSchema", "jsonUiSchema", "toJson"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema":
-            return ["jsonSchema"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema":
-            return ["jsonUiSchema"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_None":
+        case "http://purl.org/shaclmate/ontology#_TsFeatures_None":
             return [];
         case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
             return ["sparql"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
-            return ["fromRdf", "toRdf"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_ToJson":
-            return ["toJson"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf":
-            return ["toRdf"];
     }
 }
 export function tsFeatures(generated) {
     const tsFeatureIncludes = generated.tsFeatureIncludes.flatMap(iriToTsFeatures);
     const tsFeatureExcludes = generated.tsFeatureExcludes.flatMap(iriToTsFeatures);
+    if (tsFeatureExcludes.length === 0 && tsFeatureIncludes.length === 0) {
+        return Maybe.empty();
+    }
+    const tsFeatures = new Set();
     if (tsFeatureIncludes.length > 0) {
-        return Maybe.of(new Set(tsFeatureIncludes));
+        for (const tsFeatureInclude of tsFeatureIncludes) {
+            tsFeatures.add(tsFeatureInclude);
+        }
     }
-    if (tsFeatureExcludes.length > 0) {
-        const tsFeatures = new Set(TsFeature.MEMBERS);
-        for (const tsFeatureExclude of tsFeatureExcludes) {
-            tsFeatures.delete(tsFeatureExclude);
+    else {
+        for (const tsFeature of tsFeaturesDefault) {
+            tsFeatures.add(tsFeature);
         }
-        return Maybe.of(tsFeatures);
     }
-    return Maybe.empty();
+    for (const tsFeatureExclude of tsFeatureExcludes) {
+        tsFeatures.delete(tsFeatureExclude);
+    }
+    if (tsFeatures.has("graphql")) {
+        tsFeatures.add("rdf");
+    }
+    return Maybe.of(tsFeatures);
 }
+const tsFeaturesAll = [
+    "create",
+    "equals",
+    "graphql",
+    "hash",
+    "json",
+    "rdf",
+    "sparql",
+];
+export const tsFeaturesDefault = [
+    "create",
+    "equals",
+    "hash",
+    "json",
+    "rdf",
+];
 //# sourceMappingURL=tsFeatures.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.22",
+    "@shaclmate/shacl-ast": "2.0.23",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -13,15 +13,22 @@
     "@types/toposort": "2.0.7",
     "change-case": "^5.4.4",
     "pino": "^9.1.0",
+    "plur": "^5.1.0",
+    "purify-ts": "^2.1.0",
     "reserved-identifiers": "^1.0.0",
     "toposort": "2.0.2",
     "ts-invariant": "^0.10.3",
-    "ts-morph": "^24.0.0",
+    "ts-morph": "^26.0.0",
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/runtime": "2.0.22",
-    "oxigraph": "^0.4.0"
+    "@shaclmate/kitchen-sink-example": "2.0.23",
+    "@shaclmate/runtime": "2.0.23",
+    "@kos-kit/sparql-client": "2.0.115",
+    "@types/n3": "^1.21.1",
+    "oxigraph": "0.4.11",
+    "n3": "^1.21.3",
+    "rdfjs-resource": "1.0.20"
   },
   "exports": {
     ".": {
@@ -51,31 +58,26 @@
   ],
   "license": "Apache-2.0",
   "name": "@shaclmate/compiler",
+  "packageManager": "npm@10.9.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/minorg/shaclmate"
   },
   "scripts": {
     "build": "tsc -b",
+    "build:noEmit": "tsc --noEmit",
     "check": "biome check",
     "check:write": "biome check --write",
     "check:write:unsafe": "biome check --write --unsafe",
     "clean": "rimraf dist",
-    "format": "biome format",
-    "format:write": "biome format --write",
-    "format:write:unsafe": "biome format --write --unsafe",
-    "rebuild": "run-s clean build",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:noEmit": "tsc --noEmit -w --preserveWatchOutput",
     "link-dependencies": "npm link rdfjs-resource",
-    "lint": "biome lint",
-    "lint:write": "biome lint --write",
-    "lint:write:unsafe": "biome lint --write --unsafe",
     "test": "biome check && vitest run",
     "test:coverage": "biome check && vitest run --coverage",
-    "test:watch": "vitest watch",
-    "unlink": "npm unlink -g @shaclmate/compiler",
-    "watch": "tsc -w --preserveWatchOutput",
-    "watch:noEmit": "tsc --noEmit -w --preserveWatchOutput"
+    "test:watch": "biome check && vitest watch",
+    "unlink": "npm unlink -g @shaclmate/compiler"
   },
   "type": "module",
-  "version": "2.0.22"
+  "version": "2.0.23"
 }

package/dist/generators/ts/_ObjectType/fromJsonFunctionDeclarations.d.ts

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function fromJsonFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=fromJsonFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/fromJsonFunctionDeclarations.js

@@ -1,78 +0,0 @@
-import { StructureKind } from "ts-morph";
-const variables = {
-    jsonObject: "_jsonObject",
-};
-export function fromJsonFunctionDeclarations() {
-    if (!this.features.has("fromJson")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    const initializers = [];
-    const propertyReturnTypeSignatures = [];
-    const propertiesFromJsonFunctionReturnType = [];
-    const propertiesFromJsonFunctionStatements = [];
-    propertiesFromJsonFunctionStatements.push(`const _jsonSafeParseResult = ${this.jsonZodSchemaFunctionName}().safeParse(_json);`, "if (!_jsonSafeParseResult.success) { return purify.Left(_jsonSafeParseResult.error); }", `const ${variables.jsonObject} = _jsonSafeParseResult.data;`);
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}._propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
-        initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}._propertiesFromJson>>`);
-    });
-    for (const property of this.properties) {
-        const propertyFromJsonStatements = property.fromJsonStatements({
-            variables,
-        });
-        if (propertyFromJsonStatements.length > 0) {
-            propertiesFromJsonFunctionStatements.push(...propertyFromJsonStatements);
-            initializers.push(property.name);
-            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
-        }
-    }
-    propertiesFromJsonFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
-    if (propertyReturnTypeSignatures.length > 0) {
-        propertiesFromJsonFunctionReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
-    }
-    const fromJsonFunctionDeclarations = [];
-    fromJsonFunctionDeclarations.push({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "_propertiesFromJson",
-        parameters: [
-            {
-                name: "_json",
-                type: "unknown",
-            },
-        ],
-        returnType: `purify.Either<zod.ZodError, ${propertiesFromJsonFunctionReturnType.join(" & ")}>`,
-        statements: propertiesFromJsonFunctionStatements,
-    });
-    if (!this.abstract) {
-        let fromJsonStatements;
-        switch (this.declarationType) {
-            case "class":
-                fromJsonStatements = [
-                    `return ${this.name}._propertiesFromJson(json).map(properties => new ${this.name}(properties));`,
-                ];
-                break;
-            case "interface":
-                fromJsonStatements = [`return ${this.name}._propertiesFromJson(json);`];
-                break;
-        }
-        fromJsonFunctionDeclarations.push({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "fromJson",
-            parameters: [
-                {
-                    name: "json",
-                    type: "unknown",
-                },
-            ],
-            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
-            statements: fromJsonStatements,
-        });
-    }
-    return fromJsonFunctionDeclarations;
-}
-//# sourceMappingURL=fromJsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/fromRdfFunctionDeclarations.d.ts

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function fromRdfFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=fromRdfFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/fromRdfFunctionDeclarations.js

@@ -1,91 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { objectInitializer } from "../objectInitializer.js";
-const variables = {
-    context: "_context",
-    ignoreRdfType: "_ignoreRdfType",
-    languageIn: "_languageIn",
-    resource: "_resource",
-};
-export function fromRdfFunctionDeclarations() {
-    if (!this.features.has("fromRdf")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    const initializers = [];
-    const propertySignatures = [];
-    const propertiesFromRdfFunctionReturnType = [];
-    const propertiesFromRdfFunctionStatements = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}._propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
-        initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}._propertiesFromRdf>>`);
-    });
-    this.fromRdfType.ifJust((rdfType) => {
-        propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);
-    });
-    const propertyFromRdfVariables = {
-        context: variables.context,
-        languageIn: variables.languageIn,
-        resource: variables.resource,
-    };
-    for (const property of this.properties) {
-        const propertyFromRdfStatements = property.fromRdfStatements({
-            variables: propertyFromRdfVariables,
-        });
-        if (propertyFromRdfStatements.length > 0) {
-            propertiesFromRdfFunctionStatements.push(...propertyFromRdfStatements);
-            initializers.push(property.name);
-            propertySignatures.push(`${property.name}: ${property.type.name};`);
-        }
-    }
-    propertiesFromRdfFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
-    if (propertySignatures.length > 0) {
-        propertiesFromRdfFunctionReturnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
-    }
-    const fromRdfFunctionDeclarations = [];
-    fromRdfFunctionDeclarations.push({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "_propertiesFromRdf",
-        parameters: [
-            {
-                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
-                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; resource: ${this.rdfjsResourceType().name}; }`,
-            },
-        ],
-        returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${propertiesFromRdfFunctionReturnType.join(" & ")}>`,
-        statements: propertiesFromRdfFunctionStatements,
-    });
-    if (!this.abstract) {
-        let fromRdfStatements;
-        switch (this.declarationType) {
-            case "class":
-                fromRdfStatements = [
-                    `return ${this.name}._propertiesFromRdf(parameters).map(properties => new ${this.name}(properties));`,
-                ];
-                break;
-            case "interface":
-                fromRdfStatements = [
-                    `return ${this.name}._propertiesFromRdf(parameters);`,
-                ];
-                break;
-        }
-        fromRdfFunctionDeclarations.push({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "fromRdf",
-            parameters: [
-                {
-                    name: "parameters",
-                    type: `Parameters<typeof ${this.name}._propertiesFromRdf>[0]`,
-                },
-            ],
-            returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
-            statements: fromRdfStatements,
-        });
-    }
-    return fromRdfFunctionDeclarations;
-}
-//# sourceMappingURL=fromRdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonSchemaFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=jsonSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function jsonSchemaFunctionDeclaration() {
-    if (!this.features.has("jsonSchema")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "jsonSchema",
-        statements: [
-            `return zodToJsonSchema(${this.jsonZodSchemaFunctionName}());`,
-        ],
-    });
-}
-//# sourceMappingURL=jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonUiSchemaFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=jsonUiSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.js

@@ -1,31 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function jsonUiSchemaFunctionDeclaration() {
-    if (!this.features.has("jsonUiSchema")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const variables = { scopePrefix: "scopePrefix" };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => `${parentObjectType.name}.${parentObjectType.jsonUiSchemaFunctionName}({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: this.jsonUiSchemaFunctionName,
-        parameters: [
-            {
-                hasQuestionToken: true,
-                name: "parameters",
-                type: "{ scopePrefix?: string }",
-            },
-        ],
-        statements: [
-            'const scopePrefix = parameters?.scopePrefix ?? "#";',
-            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
-        ],
-    });
-}
-//# sourceMappingURL=jsonUiSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonZodSchemaFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=jsonZodSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.js

@@ -1,37 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function jsonZodSchemaFunctionDeclaration() {
-    if (!this.features.has("fromJson") && !this.features.has("jsonSchema")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const variables = { zod: "zod" };
-    const mergeZodObjectSchemas = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ variables })}`);
-    }
-    if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
-            .flatMap((property) => property.jsonZodSchema({ variables }).toList())
-            .map(({ key, schema }) => `"${key}": ${schema}`)
-            .join(",")} })`);
-    }
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: this.jsonZodSchemaFunctionName,
-        statements: [
-            `return ${mergeZodObjectSchemas.length > 0
-                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-                    if (merged.length === 0) {
-                        return zodObjectSchema;
-                    }
-                    return `${merged}.merge(${zodObjectSchema})`;
-                }, "")
-                : `${variables.zod}.object()`};`,
-        ],
-    });
-}
-//# sourceMappingURL=jsonZodSchemaFunctionDeclaration.js.map

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

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

package/dist/generators/ts/_ObjectType/rdfjsTermExpression.js

@@ -1,17 +0,0 @@
-import { xsd } from "@tpluscode/rdf-ns-builders";
-export function rdfjsTermExpression({ dataFactoryVariable, rdfjsTerm, }) {
-    switch (rdfjsTerm.termType) {
-        case "BlankNode":
-            return `${dataFactoryVariable}.blankNode("${rdfjsTerm.value}")`;
-        case "Literal":
-            if (rdfjsTerm.datatype.equals(xsd.string)) {
-                return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
-            }
-            return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", ${dataFactoryVariable}.namedNode("${rdfjsTerm.datatype.value}"))`;
-        case "NamedNode":
-            return `${dataFactoryVariable}.namedNode("${rdfjsTerm.value}")`;
-        case "Variable":
-            return `${dataFactoryVariable}.variable!("${rdfjsTerm.value}")`;
-    }
-}
-//# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/_ObjectType/toJsonFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function toJsonFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=toJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/toJsonFunctionDeclaration.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
-export function toJsonFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return toJsonFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toJsonFunctionOrMethodDeclaration) => ({
-        ...toJsonFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-//# sourceMappingURL=toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/toJsonReturnType.d.ts

@@ -1,3 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-export declare function toJsonReturnType(this: ObjectType): string;
-//# sourceMappingURL=toJsonReturnType.d.ts.map

package/dist/generators/ts/_ObjectType/toJsonReturnType.js

@@ -1,17 +0,0 @@
-export function toJsonReturnType() {
-    const typeMembers = [];
-    if (this.ownProperties.length > 0) {
-        typeMembers.push(`{ ${this.ownProperties
-            .flatMap((property) => property.jsonPropertySignature.toList())
-            .map((propertySignature) => `readonly "${propertySignature.name}": ${propertySignature.type}`)
-            .join("; ")} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        typeMembers.push(parentObjectType.jsonName);
-    }
-    if (typeMembers.length === 0) {
-        return "object";
-    }
-    return typeMembers.join(" & ");
-}
-//# sourceMappingURL=toJsonReturnType.js.map

package/dist/generators/ts/_ObjectType/toRdfFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function toRdfFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=toRdfFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/toRdfFunctionDeclaration.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
-export function toRdfFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return toRdfFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toRdfFunctionOrMethodDeclaration) => ({
-        ...toRdfFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-//# sourceMappingURL=toRdfFunctionDeclaration.js.map