@shaclmate/compiler 4.0.63 → 4.0.65

package/dist/generators/ts/LazyOptionType.js

@@ -18,16 +18,31 @@ export class LazyOptionType extends Super {
         invariant(this.resolveType.jsTypes.length === 1);
         invariant(this.resolveType.itemType.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            code: code `\
+${this.reusables.snippets.convertToLazyOption}<
+  ${this.partialType.itemType.expression},
+  ${this.resolveType.itemType.expression},
+>(
+  ${this.partialType.itemType.typeGuardFunction.unsafeCoerce()},
+  ${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })}
+)`,
             sourceTypes: [
                 {
                     expression: this.expression,
                     jsType: this.jsTypes[0],
                 },
+                {
+                    expression: this.partialType.expression,
+                    jsType: this.partialType.jsTypes[0],
+                },
                 {
                     expression: this.resolveType.expression,
                     jsType: this.resolveType.jsTypes[0],
                 },
+                {
+                    expression: this.partialType.itemType.expression,
+                    jsType: this.resolveType.itemType.jsTypes[0],
+                },
                 {
                     expression: this.resolveType.itemType.expression,
                     jsType: this.resolveType.itemType.jsTypes[0],

package/dist/generators/ts/LazySetType.js

@@ -23,16 +23,35 @@ export class LazySetType extends AbstractLazyType {
         invariant(this.jsTypes.length === 1);
         invariant(this.resolveType.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            code: code `\
+${this.reusables.snippets.convertToLazySet}<
+  ${this.partialType.itemType.expression},
+  ${this.resolveType.itemType.expression}
+>(
+  ${this.partialType.itemType.typeGuardFunction.unsafeCoerce()},
+  ${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })}
+)`,
             sourceTypes: [
                 {
                     expression: this.expression,
                     jsType: this.jsTypes[0],
                 },
+                {
+                    expression: this.partialType.expression,
+                    jsType: this.partialType.jsTypes[0],
+                },
                 {
                     expression: this.resolveType.expression,
                     jsType: this.resolveType.jsTypes[0],
                 },
+                {
+                    expression: this.partialType.itemType.expression,
+                    jsType: this.partialType.itemType.jsTypes[0],
+                },
+                {
+                    expression: this.resolveType.itemType.expression,
+                    jsType: this.resolveType.itemType.jsTypes[0],
+                },
                 {
                     expression: code `undefined`,
                     jsType: { typeof: "undefined" },

package/dist/generators/ts/LazyType.js

@@ -16,12 +16,23 @@ export class LazyType extends AbstractLazyType {
         invariant(this.jsTypes.length === 1);
         invariant(this.resolveType.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazy}<${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            code: code `\
+${this.reusables.snippets.convertToLazy}<
+  ${this.partialType.expression},
+  ${this.resolveType.expression}
+>(
+  ${this.partialType.typeGuardFunction.unsafeCoerce()},
+  ${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })}
+)`,
             sourceTypes: [
                 {
                     expression: this.expression,
                     jsType: this.jsTypes[0],
                 },
+                {
+                    expression: this.partialType.expression,
+                    jsType: this.partialType.jsTypes[0],
+                },
                 {
                     expression: this.resolveType.expression,
                     jsType: this.resolveType.jsTypes[0],

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -1,3 +1,4 @@
+import { Maybe } from "purify-ts";
 import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -7,6 +8,7 @@ export declare class ObjectDiscriminatedUnionType extends DiscriminatedUnionType
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get schema(): Code;
     get schemaType(): Code;
+    get typeGuardFunction(): Maybe<Code>;
     protected get staticModuleDeclarations(): Record<string, Code>;
 }
 //# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -4,15 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js";
 import { ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js";
 import { ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js";
 import { ObjectDiscriminatedUnionType_graphqlTypeVariableStatement } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js";
 import { ObjectDiscriminatedUnionType_identifierTypeDeclarations } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js";
-import { ObjectDiscriminatedUnionType_isTypeFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js";
 import { ObjectDiscriminatedUnionType_schemaVariableStatement } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.js";
 import { ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js";
+import { ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
@@ -42,6 +43,12 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
             .map(() => code `typeof ${this.schema}`)
             .orDefault(super.schemaType);
     }
+    get typeGuardFunction() {
+        if (Object.keys(ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.call(this)).length === 0) {
+            return Maybe.empty();
+        }
+        return this.name.map((name) => code `${name}.is${name}`);
+    }
     get staticModuleDeclarations() {
         const name = this.name.unsafeCoerce();
         return {
@@ -51,7 +58,7 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
             ...ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.call(this),
             ...ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.call(this),
             ...ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.call(this),
-            ...ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.call(this),
+            ...ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.call(this),
             ...ObjectDiscriminatedUnionType_schemaVariableStatement.call(this),
             ...(this.configuration.features.has("Object.SPARQL")
                 ? {
@@ -85,4 +92,7 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "typeGuardFunction", null);
 //# sourceMappingURL=ObjectDiscriminatedUnionType.js.map

package/dist/generators/ts/ObjectType.d.ts

@@ -56,6 +56,7 @@ export declare class ObjectType extends AbstractType {
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
+    get typeGuardFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get constructorParameters(): {

package/dist/generators/ts/ObjectType.js

@@ -22,7 +22,6 @@ import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graph
 import { ObjectType_hashFunctionExpression } from "./_ObjectType/ObjectType_hashFunctionExpression.js";
 import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
-import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
 import { ObjectType_jsonParseFunctionDeclaration } from "./_ObjectType/ObjectType_jsonParseFunctionDeclaration.js";
 import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
 import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
@@ -37,6 +36,7 @@ import { ObjectType_toJsonFunctionExpression } from "./_ObjectType/ObjectType_to
 import { ObjectType_toRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_toRdfResourceFunctionExpression.js";
 import { ObjectType_toStringFunctionExpression } from "./_ObjectType/ObjectType_toStringFunctionExpression.js";
 import { ObjectType_toStringRecordFunctionExpression } from "./_ObjectType/ObjectType_toStringRecordFunctionExpression.js";
+import { ObjectType_typeGuardFunctionExpression } from "./_ObjectType/ObjectType_typeGuardFunctionExpression.js";
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
 import { AbstractType } from "./AbstractType.js";
@@ -140,8 +140,10 @@ export class ObjectType extends AbstractType {
             if (this.configuration.features.has("Object.type")) {
                 staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_identifierTypeDeclarations.call(this));
             }
-            // isType
-            staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_isTypeFunctionDeclaration.call(this).toList());
+            // Type guard
+            ObjectType_typeGuardFunctionExpression.call(this).ifJust((typeGuardFunctionExpression) => {
+                staticModuleDeclarations.push(code `export const is${name} = ${typeGuardFunctionExpression};`);
+            });
             // type Json
             if (this.configuration.features.has("Object.JSON.type")) {
                 staticModuleDeclarations.push(code `export type Json = ${ObjectType_jsonTypeExpression.call(this)}`);
@@ -293,6 +295,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get toRdfjsResourceType() {
         return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
     }
+    get typeGuardFunction() {
+        return ObjectType_typeGuardFunctionExpression.call(this).map((expression) => this.name.map((name) => code `${name}.is${name}`).orDefault(expression));
+    }
     get valueSparqlConstructTriplesFunction() {
         return this.name
             .map((name) => code `${name}.valueSparqlConstructTriples`)
@@ -468,6 +473,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "toRdfjsResourceType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "typeGuardFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/TsGenerator.js

@@ -142,7 +142,7 @@ export class TsGenerator {
      * Synthesize the $Object union.
      */
     synthesizeUberObjectDiscriminatedUnionType({ configuration, namedObjectTypes, reusables, }) {
-        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
+        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
         invariant(filteredNamedObjectTypes.length > 0);
         const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
             for (const nodeKind of namedObjectType.identifierType.nodeKinds) {

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js

@@ -7,7 +7,7 @@ export function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction
     }
     return singleEntryRecord(`focusSparqlConstructTriples`, code `\
 export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.primaryDiscriminantValue}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
 }`);
 }
 //# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -22,7 +22,7 @@ if (focusIdentifier.termType === "Variable") {
   }));
 }`,
         code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-            patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
+            patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.primaryDiscriminantValue}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
             type: literalOf("group"),
         }}`), { on: ", " })}], type: "union" });`,
         code `return patterns;`,

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js → ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js}

@@ -1,10 +1,13 @@
 import { singleEntryRecord } from "../singleEntryRecord.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_isTypeFunctionDeclaration() {
+export function ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration() {
     if (!this.configuration.features.has("Object.type")) {
         return {};
     }
-    const name = this.name.unsafeCoerce();
+    const name = this.name.extract();
+    if (!name) {
+        return {};
+    }
     if (name === `${this.configuration.syntheticNamePrefix}Object`) {
         return {};
     }
@@ -13,4 +16,4 @@ export function ObjectDiscriminatedUnionType_isTypeFunctionDeclaration() {
       return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
     }`);
 }
-//# sourceMappingURL=ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js.map

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

@@ -10,8 +10,6 @@ export declare class ObjectType_DiscriminantProperty extends ObjectType_Abstract
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
-    readonly schema: Maybe<Code>;
-    readonly schemaType: Maybe<Code>;
     readonly value: string;
     constructor({ configuration, value, ...superParameters }: {
         value: string;
@@ -19,6 +17,8 @@ export declare class ObjectType_DiscriminantProperty extends ObjectType_Abstract
     get jsonName(): string;
     get jsonSchema(): ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
     get values(): readonly string[];
     private get constValue();
     constructorInitializer(): Maybe<Code>;

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

@@ -17,8 +17,6 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     kind = "Discriminant";
     mutable = false;
     recursive = false;
-    schema = Maybe.empty();
-    schemaType = Maybe.empty();
     value;
     constructor({ configuration, value, ...superParameters }) {
         super({
@@ -41,6 +39,12 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     get jsonSignature() {
         return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
     }
+    get schema() {
+        return Maybe.of(code `${{ kind: this.kind, value: this.value }}`);
+    }
+    get schemaType() {
+        return Maybe.of(code `${{ kind: this.kind, value: this.value }}`);
+    }
     get values() {
         return [this.value];
     }

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

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

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

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_typeGuardFunctionExpression() {
+    if (!this.configuration.features.has("Object.type")) {
+        return Maybe.empty();
+    }
+    const discriminantProperty = this.discriminantProperty.extract();
+    if (!discriminantProperty) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.expression} => object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)}`);
+}
+//# sourceMappingURL=ObjectType_typeGuardFunctionExpression.js.map

package/dist/generators/ts/_snippets/snippets_convertToLazy.js

@@ -1,15 +1,31 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazy = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazy`, code `\
-function ${syntheticNamePrefix}convertToLazy<PartialT, ResolvedT>(resolvedToPartial: (resolved: ResolvedT) => PartialT) {
-  return (value: ${snippets.Lazy}<PartialT, ResolvedT> | ResolvedT): ${imports.Either}<Error, ${snippets.Lazy}<PartialT, ResolvedT>> => {
+function ${syntheticNamePrefix}convertToLazy<PartialT, ResolvedT>(
+  isPartial: (object: PartialT | ResolvedT) => object is PartialT,
+  resolvedToPartial: (resolved: ResolvedT) => PartialT
+) {
+  return (value: ${snippets.Lazy}<PartialT, ResolvedT> | PartialT | ResolvedT): ${imports.Either}<Error, ${snippets.Lazy}<PartialT, ResolvedT>> => {
     if (value instanceof ${snippets.Lazy}) {
       return ${imports.Either}.of(value);
     }
 
-    return ${imports.Either}.of(new ${snippets.Lazy}({
-      partial: resolvedToPartial(value),
-      resolver: async () => ${imports.Right}(value)
-    }));
+    if (isPartial(value)) {
+      const partial: PartialT = value;
+      return ${imports.Either}.of(
+        new ${snippets.Lazy}({
+          partial,
+          resolver: async () => ${imports.Left}(new Error("unable to resolve"))
+        })
+      );
+    }
+
+    const resolved: ResolvedT = value;
+    return ${imports.Either}.of(
+      new ${snippets.Lazy}({
+        partial: resolvedToPartial(resolved),
+        resolver: async () => ${imports.Right}(resolved)
+      })
+    );
   };
 }`);
 //# sourceMappingURL=snippets_convertToLazy.js.map

package/dist/generators/ts/_snippets/snippets_convertToLazyOption.js

@@ -1,33 +1,47 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazyOption = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyOption`, code `\
-function ${syntheticNamePrefix}convertToLazyOption<PartialT, ResolvedT>(resolvedToPartial: (resolved: ResolvedT) => PartialT) {
-  return (value: ${snippets.LazyOption}<PartialT, ResolvedT> | ${imports.Maybe}<ResolvedT> | ResolvedT | undefined): ${imports.Either}<Error, ${snippets.LazyOption}<PartialT, ResolvedT>> => {
-    switch (typeof value) {
-      case "object": {
-        if (value instanceof ${snippets.LazyOption}) {
-          return ${imports.Either}.of(value);
-        }
+function ${syntheticNamePrefix}convertToLazyOption<PartialT, ResolvedT>(
+  isPartial: (object: PartialT | ResolvedT) => object is PartialT,
+  resolvedToPartial: (resolved: ResolvedT) => PartialT
+) {
+  return (value: ${snippets.LazyOption}<PartialT, ResolvedT> | ${imports.Maybe}<PartialT> | ${imports.Maybe}<ResolvedT> | PartialT | ResolvedT | undefined): ${imports.Either}<Error, ${snippets.LazyOption}<PartialT, ResolvedT>> => {
+    if (value instanceof ${snippets.LazyOption}) {
+      return ${imports.Either}.of(value);
+    }
+
+    let extractedValue: PartialT | ResolvedT | undefined;
+    if (typeof value === "undefined") {
+      extractedValue = value;
+    } else if (${imports.Maybe}.isMaybe(value)) {
+      extractedValue = value.extract();
+    } else {
+      extractedValue = value;
+    }
 
-        if (${imports.Maybe}.isMaybe(value)) {
-          return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
-            partial: value.map(resolvedToPartial),
-            resolver: async () => ${imports.Right}(value.unsafeCoerce())
-          }));
-        }
+    if (typeof extractedValue === "undefined") {
+      return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
+        partial: ${imports.Maybe}.empty(),
+        resolver: async () => { throw new Error("should never be called"); }
+      }));
+    }
 
-        break;
-      }
-      case "undefined":
-        return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
-          partial: ${imports.Maybe}.empty(),
-          resolver: async () => { throw new Error("should never be called"); }
-        }));
+    if (isPartial(extractedValue)) {
+      const partial: PartialT = extractedValue;
+      return ${imports.Either}.of(
+        new ${snippets.LazyOption}({
+          partial: ${imports.Maybe}.of(partial),
+          resolver: async () => ${imports.Left}(new Error("unable to resolve"))
+        })
+      );
     }
 
-    return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
-      partial: ${imports.Maybe}.of(resolvedToPartial(value)),
-      resolver: async () => ${imports.Right}(value)
-    }));
+    const resolved: ResolvedT = extractedValue;
+    return ${imports.Either}.of(
+      new ${snippets.LazyOption}({
+        partial: ${imports.Maybe}.of(resolvedToPartial(resolved)),
+        resolver: async () => ${imports.Right}(resolved)
+      })
+    );
   };
 }`);
 //# sourceMappingURL=snippets_convertToLazyOption.js.map

package/dist/generators/ts/_snippets/snippets_convertToLazySet.js

@@ -1,27 +1,40 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazySet`, code `\
-function ${syntheticNamePrefix}convertToLazySet<PartialT, ResolvedT>(resolvedToPartial: (resolved: ResolvedT) => PartialT) {
-  return (value: ${snippets.LazySet}<PartialT, ResolvedT> | readonly ResolvedT[] | undefined): ${imports.Either}<Error, ${snippets.LazySet}<PartialT, ResolvedT>> => {
-    switch (typeof value) {
-      case "object": {
-        if (value instanceof ${snippets.LazySet}) {
-          return ${imports.Either}.of(value);
-        }
+function ${syntheticNamePrefix}convertToLazySet<PartialT, ResolvedT>(
+  isPartial: (object: PartialT | ResolvedT) => object is PartialT,
+  resolvedToPartial: (resolved: ResolvedT) => PartialT
+) {
+  return (value: ${snippets.LazySet}<PartialT, ResolvedT> | readonly PartialT[] | readonly ResolvedT[] | PartialT | ResolvedT | undefined): ${imports.Either}<Error, ${snippets.LazySet}<PartialT, ResolvedT>> => {
+    if (typeof value === "undefined") {
+      return ${imports.Either}.of(new ${snippets.LazySet}<PartialT, ResolvedT>({
+        partials: [],
+        resolver: async () => ${imports.Right}([])
+      }));
+    }
+
+    if (value instanceof ${snippets.LazySet}) {
+      return ${imports.Either}.of(value);
+    }
+
+    const arrayValue = (Array.isArray(value) ? value : [value]) as readonly PartialT[] | readonly ResolvedT[];
 
-        break;
-      }
-      case "undefined":
-        return ${imports.Either}.of(new ${snippets.LazySet}<PartialT, ResolvedT>({
-          partials: [],
-          resolver: async () => ${imports.Right}([])
-        }));
+    if (arrayValue.every(isPartial)) {
+      const partials: readonly PartialT[] = arrayValue;
+      return ${imports.Either}.of(
+        new ${snippets.LazySet}<PartialT, ResolvedT>({
+          partials,
+          resolver: async () => ${imports.Left}(new Error("unable to resolve"))
+        })
+      );
     }
 
-    const captureValue = value;
-    return ${imports.Either}.of(new ${snippets.LazySet}<PartialT, ResolvedT>({
-      partials: value.map(resolvedToPartial),
-      resolver: async () => ${imports.Right}(captureValue)
-    }));
+    const resolved: readonly ResolvedT[] = arrayValue;
+    return ${imports.Either}.of(
+      new ${snippets.LazySet}<PartialT, ResolvedT>({
+        partials: resolved.map(resolvedToPartial),
+        resolver: async () => ${imports.Right}(resolved)
+      })
+    );
   };
 }`);
 //# sourceMappingURL=snippets_convertToLazySet.js.map

package/dist/input/input.shaclmate.d.ts

@@ -246,7 +246,7 @@ export declare namespace NodeShape {
         const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
         const stringify: typeof NTriplesTerm.stringify;
     }
-    function isNodeShape(object: $Object): object is NodeShape;
+    const isNodeShape: (object: $Object) => object is NodeShape;
     const schema: {
         readonly fromRdfType: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#NodeShape">;
         readonly properties: {
@@ -744,7 +744,7 @@ export declare namespace Ontology {
         const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
         const stringify: typeof NTriplesTerm.stringify;
     }
-    function isOntology(object: $Object): object is Ontology;
+    const isOntology: (object: $Object) => object is Ontology;
     const schema: {
         readonly fromRdfType: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/2002/07/owl#Ontology">;
         readonly properties: {
@@ -808,7 +808,7 @@ export declare namespace PropertyGroup {
         const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
         const stringify: typeof NTriplesTerm.stringify;
     }
-    function isPropertyGroup(object: $Object): object is PropertyGroup;
+    const isPropertyGroup: (object: $Object) => object is PropertyGroup;
     const schema: {
         readonly fromRdfType: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#PropertyGroup">;
         readonly properties: {
@@ -1025,7 +1025,7 @@ export declare namespace PropertyShape {
         const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
         const stringify: typeof NTriplesTerm.stringify;
     }
-    function isPropertyShape(object: $Object): object is PropertyShape;
+    const isPropertyShape: (object: $Object) => object is PropertyShape;
     const schema: {
         readonly fromRdfType: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#PropertyShape">;
         readonly properties: {
@@ -1601,7 +1601,7 @@ export declare namespace ValidationReport {
         const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
         const stringify: typeof NTriplesTerm.stringify;
     }
-    function isValidationReport(object: $Object): object is ValidationReport;
+    const isValidationReport: (object: $Object) => object is ValidationReport;
     const schema: {
         readonly fromRdfType: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#ValidationReport">;
         readonly properties: {
@@ -1772,7 +1772,7 @@ export declare namespace ValidationResult {
         const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
         const stringify: typeof NTriplesTerm.stringify;
     }
-    function isValidationResult(object: $Object): object is ValidationResult;
+    const isValidationResult: (object: $Object) => object is ValidationResult;
     const schema: {
         readonly fromRdfType: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#ValidationResult">;
         readonly properties: {
@@ -1876,7 +1876,7 @@ export declare namespace Shape {
     }
     function isShape(object: $Object): object is Shape;
     const schema: {
-        readonly kind: "ObjectUnion";
+        readonly kind: "ObjectDiscriminatedUnion";
         readonly members: {
             readonly NodeShape: {
                 readonly discriminantValues: readonly ["NodeShape"];
@@ -3255,7 +3255,7 @@ export declare namespace $Object {
         const stringify: typeof NTriplesTerm.stringify;
     }
     const schema: {
-        readonly kind: "ObjectUnion";
+        readonly kind: "ObjectDiscriminatedUnion";
         readonly members: {
             readonly NodeShape: {
                 readonly discriminantValues: readonly ["NodeShape"];

package/dist/input/input.shaclmate.js

@@ -178,7 +178,7 @@ function $listFromRdfResourceValues(itemFromRdfResourceValues) {
 }
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 function $literalFromRdfResourceValues(values, options) {
-    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toLiteral()));
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toLiteral(options.schema.in)));
 }
 function $maybeFromRdfResourceValues(itemFromRdfResourceValues) {
     return (values, options) => itemFromRdfResourceValues(values, {
@@ -234,6 +234,7 @@ var $RdfVocabularies;
 (function ($RdfVocabularies) {
     $RdfVocabularies.rdf = {
         first: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first"),
+        langString: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"),
         nil: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"),
         rest: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"),
         subject: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject"),
@@ -324,7 +325,7 @@ function $termFromRdfResourceValues(values, options) {
         if (!schema.types.some((type) => term.termType === type)) {
             return Left(new Resource.MistypedValueError({
                 actualValue: term,
-                expectedValueType: "Term types",
+                expectedValueType: "BlankNode | Literal | NamedNode",
                 focusResource,
                 propertyPath,
             }));
@@ -801,10 +802,7 @@ export var NodeShape;
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = NodeShape.Identifier || (NodeShape.Identifier = {}));
-    function isNodeShape(object) {
-        return object.$type === "NodeShape";
-    }
-    NodeShape.isNodeShape = isNodeShape;
+    NodeShape.isNodeShape = (object) => object.$type === "NodeShape";
     NodeShape.schema = {
         fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
         properties: {
@@ -1446,10 +1444,7 @@ export var Ontology;
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
-    function isOntology(object) {
-        return object.$type === "Ontology";
-    }
-    Ontology.isOntology = isOntology;
+    Ontology.isOntology = (object) => object.$type === "Ontology";
     Ontology.schema = {
         fromRdfType: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
         properties: {
@@ -1545,10 +1540,7 @@ export var PropertyGroup;
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
-    function isPropertyGroup(object) {
-        return object.$type === "PropertyGroup";
-    }
-    PropertyGroup.isPropertyGroup = isPropertyGroup;
+    PropertyGroup.isPropertyGroup = (object) => object.$type === "PropertyGroup";
     PropertyGroup.schema = {
         fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
         properties: {
@@ -2036,10 +2028,7 @@ export var PropertyShape;
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
-    function isPropertyShape(object) {
-        return object.$type === "PropertyShape";
-    }
-    PropertyShape.isPropertyShape = isPropertyShape;
+    PropertyShape.isPropertyShape = (object) => object.$type === "PropertyShape";
     PropertyShape.schema = {
         fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
         properties: {
@@ -2774,10 +2763,7 @@ export var ValidationReport;
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = ValidationReport.Identifier || (ValidationReport.Identifier = {}));
-    function isValidationReport(object) {
-        return object.$type === "ValidationReport";
-    }
-    ValidationReport.isValidationReport = isValidationReport;
+    ValidationReport.isValidationReport = (object) => object.$type === "ValidationReport";
     ValidationReport.schema = {
         fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationReport"),
         properties: {
@@ -2936,10 +2922,7 @@ export var ValidationResult;
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = ValidationResult.Identifier || (ValidationResult.Identifier = {}));
-    function isValidationResult(object) {
-        return object.$type === "ValidationResult";
-    }
-    ValidationResult.isValidationResult = isValidationResult;
+    ValidationResult.isValidationResult = (object) => object.$type === "ValidationResult";
     ValidationResult.schema = {
         fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationResult"),
         properties: {
@@ -3094,7 +3077,7 @@ export var Shape;
     }
     Shape.isShape = isShape;
     Shape.schema = {
-        kind: "ObjectUnion",
+        kind: "ObjectDiscriminatedUnion",
         members: {
             NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.schema },
             PropertyShape: {
@@ -3496,7 +3479,7 @@ export var $Object;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = $Object.Identifier || ($Object.Identifier = {}));
     $Object.schema = {
-        kind: "ObjectUnion",
+        kind: "ObjectDiscriminatedUnion",
         members: {
             NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.schema },
             Ontology: { discriminantValues: ["Ontology"], type: Ontology.schema },

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.63",
+    "@shaclmate/shacl-ast": "4.0.65",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -283,12 +283,12 @@
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js",
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.d.ts",
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js",
-    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.d.ts",
-    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js",
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.d.ts",
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.js",
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.d.ts",
     "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js",
     "dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.js",
     "dist/generators/ts/_ObjectType/ObjectType_DiscriminantProperty.d.ts",
@@ -321,8 +321,6 @@
     "dist/generators/ts/_ObjectType/ObjectType_hashFunctionExpression.js",
     "dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.js",
-    "dist/generators/ts/_ObjectType/ObjectType_isTypeFunctionDeclaration.d.ts",
-    "dist/generators/ts/_ObjectType/ObjectType_isTypeFunctionDeclaration.js",
     "dist/generators/ts/_ObjectType/ObjectType_jsonParseFunctionDeclaration.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_jsonParseFunctionDeclaration.js",
     "dist/generators/ts/_ObjectType/ObjectType_jsonSchemaExpression.d.ts",
@@ -349,6 +347,8 @@
     "dist/generators/ts/_ObjectType/ObjectType_toStringFunctionExpression.js",
     "dist/generators/ts/_ObjectType/ObjectType_toStringRecordFunctionExpression.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_toStringRecordFunctionExpression.js",
+    "dist/generators/ts/_ObjectType/ObjectType_typeGuardFunctionExpression.d.ts",
+    "dist/generators/ts/_ObjectType/ObjectType_typeGuardFunctionExpression.js",
     "dist/generators/ts/_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js",
     "dist/generators/ts/_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.d.ts",
@@ -721,5 +721,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.63"
+  "version": "4.0.65"
 }

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.d.ts

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

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

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

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

@@ -1,20 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, literalOf } from "../ts-poet-wrapper.js";
-export function ObjectType_isTypeFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.type")) {
-        return Maybe.empty();
-    }
-    if (this.synthetic) {
-        return Maybe.empty();
-    }
-    const name = this.name.extract();
-    const discriminantProperty = this.discriminantProperty.extract();
-    if (!name || !discriminantProperty) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
-  return object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)};
-}`);
-}
-//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map