@shaclmate/compiler 4.0.66 → 4.0.67

package/dist/generators/ts/UberObjectDiscriminatedUnionType.d.ts

@@ -0,0 +1,29 @@
+import { Maybe } from "purify-ts";
+import type { Logger } from "ts-log";
+import type { ObjectType } from "./ObjectType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * The $Object discriminated union used in type guard functions (isSomeObjectType(object: $Object)) and some convenience methods.
+ */
+export declare class UberObjectDiscriminatedUnionType {
+    private readonly configuration;
+    private readonly members;
+    private readonly reusables;
+    constructor({ configuration, members, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        members: readonly ObjectType[];
+        reusables: Reusables;
+    });
+    get declaration(): Maybe<Code>;
+    private get equalsFunctionDeclaration();
+    private get name();
+    private get toJsonFunctionDeclaration();
+    private get toRdfResourceFunctionDeclaration();
+    private get hashFunctionDeclaration();
+    private get toStringFunctionDeclaration();
+    private memberTypeSwitch;
+}
+//# sourceMappingURL=UberObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/UberObjectDiscriminatedUnionType.js

@@ -0,0 +1,144 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * The $Object discriminated union used in type guard functions (isSomeObjectType(object: $Object)) and some convenience methods.
+ */
+export class UberObjectDiscriminatedUnionType {
+    configuration;
+    members;
+    reusables;
+    constructor({ configuration, members, reusables, }) {
+        this.configuration = configuration;
+        this.members = members.filter((member) => !member.extern);
+        invariant(this.members.every((member) => member.name.isJust()));
+        this.reusables = reusables;
+    }
+    get declaration() {
+        if (this.members.length === 0) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(this.name)} = ${this.members.map((member) => member.name.unsafeCoerce()).join(" | ")};`);
+        }
+        const staticModuleDeclarations = [
+            ...this.equalsFunctionDeclaration.toList(),
+            ...this.hashFunctionDeclaration.toList(),
+            ...this.toJsonFunctionDeclaration.toList(),
+            ...this.toRdfResourceFunctionDeclaration.toList(),
+            ...this.toStringFunctionDeclaration.toList(),
+        ];
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(this.name)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
+        }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get equalsFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.equals")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const equals = ${this.members[0].name.unsafeCoerce()}.equals`);
+        }
+        return Maybe.of(code `\
+export function equals(left: ${this.name}, right: ${this.name}): ${this.reusables.snippets.EqualsResult} {
+  if (left.${this.configuration.objectDiscriminantProperty.name} !== right.${this.configuration.objectDiscriminantProperty.name}) {
+    return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+  }
+
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.equalsFunction}(left, right as ${member.name.unsafeCoerce()});`,
+            variables: { value: code `left` },
+        })}
+}`);
+    }
+    get name() {
+        return `${this.configuration.syntheticNamePrefix}Object`;
+    }
+    get toJsonFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toJson")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const toJson = ${this.members[0].name.unsafeCoerce()}.toJson;`);
+        }
+        return Maybe.of(code `\
+export function toJson(object: ${this.name}) {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.toJsonExpression({ variables: { value: code `object` } })};`,
+            variables: { value: code `object` },
+        })}
+}`);
+    }
+    get toRdfResourceFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toRdf")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const toRdfResource = ${this.members[0].name.unsafeCoerce()}.toRdfResource;`);
+        }
+        return Maybe.of(code `\
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (object, options) => {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.name.unsafeCoerce()}.toRdfResource(object, options);`,
+            variables: { value: code `object` },
+        })}
+};`);
+    }
+    get hashFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.hash")) {
+            return Maybe.empty();
+        }
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const hash = ${this.members[0].name.unsafeCoerce()}.hash;`);
+        }
+        return Maybe.of(code `\
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, object: ${this.name}): HasherT {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.hashFunction}(hasher, object);`,
+            variables: { value: code `object` },
+        })}
+}`);
+    }
+    get toStringFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toString")) {
+            return Maybe.empty();
+        }
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        if (this.members.length === 1) {
+            return Maybe.of(code `export const ${syntheticNamePrefix}toString = ${this.members[0].name.unsafeCoerce()}.${syntheticNamePrefix}toString;`);
+        }
+        return Maybe.of(code `\
+export function ${syntheticNamePrefix}toString(object: ${this.name}) {
+${this.memberTypeSwitch({
+            caseBlock: (member) => code `return ${member.toStringExpression({ variables: { value: code `object` } })};`,
+            variables: { value: code `object` },
+        })}
+}`);
+    }
+    memberTypeSwitch({ caseBlock, variables, }) {
+        return code `\
+switch (${variables.value}.${this.configuration.objectDiscriminantProperty.name}) {
+${joinCode(this.members.map((member) => code `case "${member.discriminantProperty.unsafeCoerce().value}": ${caseBlock(member)}`), { on: "\n" })}
+default: ${variables.value} satisfies never; throw new Error("should never reach this point");
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], UberObjectDiscriminatedUnionType.prototype, "name", null);
+//# sourceMappingURL=UberObjectDiscriminatedUnionType.js.map

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

@@ -19,6 +19,7 @@ namespace ${syntheticNamePrefix}RdfVocabularies {
     byte: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#byte"),
     date: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#date"),
     dateTime: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
+    dateTimeStamp: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#dateTimeStamp"),
     decimal: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
     double: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#double"),
     float: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#float"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.66",
+    "@shaclmate/shacl-ast": "4.0.67",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -227,6 +227,8 @@
     "dist/generators/ts/TypeFactory.js",
     "dist/generators/ts/Typeof.d.ts",
     "dist/generators/ts/Typeof.js",
+    "dist/generators/ts/UberObjectDiscriminatedUnionType.d.ts",
+    "dist/generators/ts/UberObjectDiscriminatedUnionType.js",
     "dist/generators/ts/ZodGenerator.d.ts",
     "dist/generators/ts/ZodGenerator.js",
     "dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.d.ts",
@@ -721,5 +723,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.66"
+  "version": "4.0.67"
 }