@shaclmate/compiler 4.0.50 → 4.0.52

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

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

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

@@ -0,0 +1,22 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonSchemaExpression() {
+    const properties = this.properties
+        .flatMap((property) => property.jsonSchema.toList())
+        .map(({ key, schema }) => code `"${key}": ${schema}`);
+    // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
+    let expression = code `${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}})`;
+    const meta = {
+    // id: this.name,
+    };
+    this.comment.ifJust((description) => {
+        meta["description"] = description;
+    });
+    this.label.ifJust((label) => {
+        meta["title"] = label;
+    });
+    if (Object.keys(meta).length > 0) {
+        expression = code `${expression}.meta(${meta})`;
+    }
+    return expression;
+}
+//# sourceMappingURL=ObjectType_jsonSchemaExpression.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonTypeExpression() {
+    return code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`;
+}
+//# sourceMappingURL=ObjectType_jsonTypeExpression.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonUiSchemaFunctionExpression() {
+    const variables = { scopePrefix: code `scopePrefix` };
+    const uiSchema = {
+        elements: code `${arrayOf(...this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()))}`,
+        type: "Group",
+    };
+    this.name.ifJust((name) => {
+        uiSchema["label"] = code `${literalOf(name)}`;
+    });
+    return code `\
+((parameters?: { scopePrefix?: string }): any => {
+  const scopePrefix = parameters?.scopePrefix ?? "#";
+  return ${uiSchema};
+})`;
+}
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionExpression.js.map

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

@@ -0,0 +1,11 @@
+import type { TsGenerator } from "../TsGenerator.js";
+export declare function ObjectType_objectSetMethodNames(this: {
+    readonly name: string;
+    readonly configuration: TsGenerator.Configuration;
+}): {
+    object: string;
+    objectCount: string;
+    objectIdentifiers: string;
+    objects: string;
+};
+//# sourceMappingURL=ObjectType_objectSetMethodNames.d.ts.map

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

@@ -0,0 +1,23 @@
+import { camelCase, trainCase } from "change-case";
+import plur from "plur";
+export function ObjectType_objectSetMethodNames() {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    const prefixSingular = camelCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    });
+    const thisNameParts = trainCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    }).split("-");
+    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`, { prefixCharacters: syntheticNamePrefix });
+    if (prefixPlural === prefixSingular) {
+        // Happens with singular-s nouns like "series"
+        prefixPlural = `${prefixPlural}s`;
+    }
+    return {
+        object: prefixSingular,
+        objectCount: `${prefixSingular}Count`,
+        objectIdentifiers: `${prefixSingular}Identifiers`,
+        objects: prefixPlural,
+    };
+}
+//# sourceMappingURL=ObjectType_objectSetMethodNames.js.map

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

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

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

@@ -0,0 +1,21 @@
+import { invariant } from "ts-invariant";
+import { arrayOf, code } from "../ts-poet-wrapper.js";
+export function ObjectType_schemaExpression() {
+    const schema = {};
+    this.fromRdfType.ifJust((fromRdfType) => {
+        schema["fromRdfType"] = this.rdfjsTermExpression(fromRdfType);
+    });
+    const properties = {};
+    for (const property of this.properties) {
+        property.schema.ifJust((propertySchema) => {
+            properties[property.name] = propertySchema;
+        });
+    }
+    invariant(Object.keys(properties).length > 0);
+    schema["properties"] = properties;
+    if (this.toRdfTypes.length > 0) {
+        schema["toRdfTypes"] = arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)));
+    }
+    return code `${schema} as const`;
+}
+//# sourceMappingURL=ObjectType_schemaExpression.js.map

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

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

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

@@ -0,0 +1,18 @@
+import { invariant } from "ts-invariant";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_schemaTypeExpression() {
+    const schemaType = {};
+    this.fromRdfType.ifJust(() => {
+        schemaType["fromRdfType"] = code `${this.reusables.imports.NamedNode}`;
+    });
+    const properties = {};
+    for (const property of this.properties) {
+        property.schemaType.ifJust((propertySchemaType) => {
+            properties[property.name] = propertySchemaType;
+        });
+    }
+    invariant(Object.keys(properties).length > 0);
+    schemaType["properties"] = properties;
+    return code `${schemaType}`;
+}
+//# sourceMappingURL=ObjectType_schemaTypeExpression.js.map

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

@@ -0,0 +1,10 @@
+import type { Reusables } from "../Reusables.js";
+import type { TsGenerator } from "../TsGenerator.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
+    readonly name: string;
+    readonly configuration: TsGenerator.Configuration;
+    readonly filterType: Code;
+    readonly reusables: Reusables;
+}): Code;
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,35 @@
+import { camelCase } from "change-case";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
+    return code `\
+export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable} } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${this.reusables.imports.sparqljs}.ConstructQuery {
+  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
+
+  return {
+    ...queryParameters,
+    prefixes: prefixes ?? {},
+    queryType: "CONSTRUCT",
+    template: (queryParameters.template ?? []).concat(
+      ${this.name}.focusSparqlConstructTriples({
+        filter,
+        focusIdentifier: subject,
+        ignoreRdfType: !!ignoreRdfType,
+        variablePrefix
+      })
+    ),
+    type: "query",
+    where: (queryParameters.where ?? []).concat(
+      ${this.reusables.snippets.normalizeSparqlWherePatterns}(
+        ${this.name}.focusSparqlWherePatterns({
+          filter,
+          focusIdentifier: subject,
+          ignoreRdfType: !!ignoreRdfType,
+          preferredLanguages,
+          variablePrefix
+        })
+      )
+    )
+  };
+}`;
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

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

@@ -0,0 +1,10 @@
+import type { Reusables } from "../Reusables.js";
+import type { TsGenerator } from "../TsGenerator.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly name: string;
+    readonly configuration: TsGenerator.Configuration;
+    readonly filterType: Code;
+    readonly reusables: Reusables;
+}): Code;
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
+    return code `\
+export function sparqlConstructQueryString(parameters: Parameters<typeof ${this.name}.sparqlConstructQuery>[0] & ${this.reusables.imports.sparqljs}.GeneratorOptions): string {
+  return new ${this.reusables.imports.sparqljs}.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));
+}`;
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toJsonFunctionExpression() {
+    return code `\
+((${this.thisVariable}) => JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
+        .toJsonInitializer({
+        variables: {
+            value: property.accessExpression({
+                variables: { object: this.thisVariable },
+            }),
+        },
+    })
+        .toList()), { on: "," })} } satisfies ${this.jsonType().expression})))`;
+}
+//# sourceMappingURL=ObjectType_toJsonFunctionExpression.js.map

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

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

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

@@ -0,0 +1,33 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toRdfResourceFunctionExpression() {
+    const statements = [];
+    this.toRdfTypesVariable.ifJust((toRdfTypesVariable) => {
+        statements.push(code `if (!${variables.ignoreRdfType}) { ${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${toRdfTypesVariable}, ${variables.graph}); }`);
+    });
+    for (const property of this.properties) {
+        statements.push(...property.toRdfRdfResourceValuesStatements({
+            variables: {
+                graph: variables.graph,
+                resource: variables.resource,
+                resourceSet: variables.resourceSet,
+                value: property.accessExpression({
+                    variables: { object: variables.object },
+                }),
+            },
+        }));
+    }
+    statements.push(code `return ${variables.resource};`);
+    return code `\
+((parameters) => {
+  ${joinCode(statements)}
+})`;
+}
+const variables = {
+    ignoreRdfType: code `parameters.ignoreRdfType`,
+    graph: code `parameters.graph`,
+    object: code `parameters.object`,
+    resource: code `parameters.resource`,
+    resourceSet: code `parameters.resourceSet`,
+};
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionExpression.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringFunctionExpression() {
+    return this.name
+        .map((name) => code `((${this.thisVariable}) => \`${name}(\${JSON.stringify(toStringRecord(${this.thisVariable}))})\`)`)
+        .orDefault(code `((${this.thisVariable}) => JSON.stringify(${this.toStringRecordExpression({ variables: { value: this.thisVariable } })}))`);
+}
+//# sourceMappingURL=ObjectType_toStringFunctionExpression.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringRecordFunctionExpression() {
+    return code `((${this.thisVariable}) => ${this.toStringRecordExpression({ variables: { value: this.thisVariable } })})`;
+}
+//# sourceMappingURL=ObjectType_toStringRecordFunctionExpression.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+import { ObjectType_focusSparqlConstructTriplesFunctionExpression } from "./ObjectType_focusSparqlConstructTriplesFunctionExpression.js";
+export function ObjectType_valueSparqlConstructTriplesFunctionExpression() {
+    return code `\
+(({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
+  ${this.name.map((name) => code `${name}.focusSparqlConstructTriples`).orDefaultLazy(() => ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this))}({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix }))`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionExpression.js.map

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

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

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

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+import { ObjectType_focusSparqlWherePatternsFunctionExpression } from "./ObjectType_focusSparqlWherePatternsFunctionExpression.js";
+export function ObjectType_valueSparqlWherePatternsFunctionExpression() {
+    return code `\
+(({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
+  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
+    ${this.name.map((name) => code `${name}.focusSparqlWherePatterns`).orDefaultLazy(() => ObjectType_focusSparqlWherePatternsFunctionExpression.call(this))}({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+))`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionExpression.js.map

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

@@ -0,0 +1,6 @@
+import type { Type } from "../Type.js";
+import type { DiscriminantProperty } from "./DiscriminantProperty.js";
+import type { IdentifierProperty } from "./IdentifierProperty.js";
+import type { ShaclProperty } from "./ShaclProperty.js";
+export type Property = IdentifierProperty | ShaclProperty<Type> | DiscriminantProperty;
+//# sourceMappingURL=Property.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Property.js.map

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

@@ -0,0 +1,53 @@
+import type { PropertyPath } from "@rdfx/resource";
+import { Maybe } from "purify-ts";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<TypeT> {
+    private readonly comment;
+    private readonly description;
+    private readonly display;
+    private readonly label;
+    readonly kind = "Shacl";
+    readonly mutable: boolean;
+    readonly path: PropertyPath;
+    readonly recursive: boolean;
+    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }: {
+        comment: Maybe<string>;
+        description: Maybe<string>;
+        display: boolean;
+        label: Maybe<string>;
+        mutable: boolean;
+        path: PropertyPath;
+        recursive: boolean;
+    } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
+    get constructorParameter(): Maybe<{
+        hasQuestionToken: boolean;
+        signature: Code;
+    }>;
+    get declaration(): Code;
+    get filterProperty(): Maybe<{
+        name: string;
+        type: Code;
+    }>;
+    get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
+    get hashFunctionParameter(): Code;
+    get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
+    get jsonSignature(): Maybe<Code>;
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
+    private get schemaVariable();
+    private get typeSchemaVariable();
+    constructorInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["constructorInitializer"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
+    toJsonInitializer(parameters: Parameters<AbstractProperty<TypeT>["toJsonInitializer"]>[0]): Maybe<Code>;
+    toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
+    toStringInitializer(parameters: Parameters<AbstractProperty<TypeT>["toStringInitializer"]>[0]): Maybe<Code>;
+    private propertyPathToCode;
+}
+//# sourceMappingURL=ShaclProperty.d.ts.map