@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/AbstractType.d.ts

@@ -5,6 +5,10 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    /**
+     * Is the type abstract?
+     */
+    abstract readonly abstract: boolean;
     /**
      * Comment from rdfs:comment.
      */
@@ -13,6 +17,10 @@ export declare abstract class AbstractType {
      * Expressions that convert a source type or types to this type. It should include the type itself.
      */
     abstract readonly conversions: readonly AbstractType.Conversion[];
+    /**
+     * The declaration of named types.
+     */
+    abstract readonly declaration: Maybe<Code>;
     /**
      * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
      */
@@ -57,6 +65,10 @@ export declare abstract class AbstractType {
      * TypeScript name of the type.
      */
     abstract readonly name: Code | string;
+    /**
+     * Does this type directly or indirectly reference itself?
+     */
+    abstract readonly recursive: boolean;
     /**
      * TypeScript object describing this type, for runtime use.
      */
@@ -66,20 +78,24 @@ export declare abstract class AbstractType {
      */
     abstract readonly schemaType: Code;
     /**
-     * A SparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property of this type.
+     * JavaScript typeof(s) the type.
+     */
+    abstract readonly typeofs: NonEmptyList<Typeof>;
+    /**
+     * A ValueSparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property value of this type.
      *
-     * The function takes a parameters object (type: SparqlConstructTriplesFunctionParameters) with the following parameters:
+     * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
      * - ignoreRdfType: boolean
      * - schema: instance of this.schemaType
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
-    abstract readonly sparqlConstructTriplesFunction: Code;
+    abstract readonly valueSparqlConstructTriplesFunction: Code;
     /**
-     * A SparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property of this type.
+     * A ValueSparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property value of this type.
      *
-     * The function takes a parameters object (type: SparqlWherePatternsFunctionParameters) with the following parameters:
+     * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
      * - preferredLanguages: array of preferred language code (strings) | undefined
      * - propertyPatterns: array of sparqljs.Pattern's for the property; may be empty
@@ -87,11 +103,7 @@ export declare abstract class AbstractType {
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
-    abstract readonly sparqlWherePatternsFunction: Code;
-    /**
-     * JavaScript typeof(s) the type.
-     */
-    abstract readonly typeofs: NonEmptyList<Typeof>;
+    abstract readonly valueSparqlWherePatternsFunction: Code;
     constructor({ comment, label, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
@@ -115,7 +127,7 @@ export declare abstract class AbstractType {
      * An expression that converts a Either<Error, rdfjsResource.Resource.Values> to a
      * Either<Error, rdfjsResource.Resource.Values<this type>>.
      *
-     * These expressions are used to deserialize property values in an ObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
+     * These expressions are used to deserialize property values in an NamedObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
      * that has a type parameter of this Type).
      *
      * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
@@ -124,7 +136,7 @@ export declare abstract class AbstractType {
      * Values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
      * (if it exists) is always of the first preferred language.
      *
-     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
+     * variables are runtime variables, most derived from the parameters of the NamedObjectType's fromRdf function:
      *   context: unanticipated properties (...) passed to Object.fromRdf
      *   graph: DefaultGraph | NamedNode | undefined to match (subject, predicate, object) triples in; if undefined, match triples in all graphs
      *   ignoreRdfType: whether the RDF type of objects/object unions should be ignored
@@ -134,7 +146,7 @@ export declare abstract class AbstractType {
      *   resource: the Resource passed to Object.fromRdf
      *   resourceValues: the Either<Error, rdfjsResource.Resource.Values> to be converted to values of this type
      */
-    abstract fromRdfExpression(parameters: {
+    abstract fromRdfResourceValuesExpression(parameters: {
         variables: {
             context: Code;
             graph: Code;
@@ -183,12 +195,12 @@ export declare abstract class AbstractType {
      * Zod schema for the JSON type of this type.
      *
      * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
+     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
      * "type": from another Type e.g., an OptionType or UnionType
      *
      * z.lazy() should only be returned for "property".
      */
-    abstract jsonZodSchema(parameters: {
+    abstract jsonSchema(parameters: {
         includeDiscriminantProperty?: boolean;
         context: "property" | "type";
     }): Code;
@@ -206,14 +218,14 @@ export declare abstract class AbstractType {
      * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
      *   resource.add(predicate, convertedValue, graph)
      *
-     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
+     * variables are runtime variables, most derived from the parameters of the NamedObjectType's fromRdf function:
      *   graph: DefaultGraph | NamedNode | undefined to .add to; if undefined, add to the default graph
      *   propertyPath: predicate path (NamedNode) or InversePath on a predicate path
      *   resource: the Resource to .add to
      *   resourceSet: ResourceSet for any new Resources needed while conversion (of e.g., nested objects)
      *   value: value of this type, to be converted to (BlankNode | Literal | NamedNode | bigint | boolean | number | string) or an array of the same
      */
-    abstract toRdfExpression(parameters: {
+    abstract toRdfResourceValuesExpression(parameters: {
         variables: {
             graph: Code;
             propertyPath: Code;
@@ -231,9 +243,12 @@ export declare namespace AbstractType {
         readonly sourceTypeof: Typeof;
     }
     interface DiscriminantProperty {
+        readonly descendantValues: readonly DiscriminantProperty.Value[];
         readonly name: string;
-        readonly ownValues: readonly string[];
-        readonly descendantValues: readonly string[];
+        readonly ownValues: readonly DiscriminantProperty.Value[];
+    }
+    namespace DiscriminantProperty {
+        type Value = number | string;
     }
     class GraphqlType {
         /**

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -0,0 +1,80 @@
+import { Maybe } from "purify-ts";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
+    private readonly discriminant;
+    private readonly identifierType;
+    readonly abstract = false;
+    private readonly lazyMembers;
+    readonly recursive: boolean;
+    constructor({ identifierType, members, recursive, ...superParameters }: {
+        identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+        members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
+            readonly discriminantValue: Maybe<number | string>;
+        })[];
+        recursive: boolean;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get conversions(): readonly AbstractType.Conversion[];
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
+    get mutable(): boolean;
+    get schema(): Code;
+    get schemaType(): Code;
+    get typeofs(): AbstractType["typeofs"];
+    protected get concreteMembers(): readonly AbstractUnionType.ConcreteMember<MemberTypeT>[];
+    protected get inlineEqualsFunction(): Code;
+    protected get inlineFilterFunction(): Code;
+    protected get inlineFilterType(): Code;
+    protected get inlineFromJsonFunction(): Code;
+    protected get inlineFromRdfResourceValuesFunction(): Code;
+    protected get inlineJsonType(): AbstractType.JsonType;
+    protected get inlineJsonSchema(): Code;
+    protected get inlineName(): Code;
+    protected get inlineValueSparqlConstructTriplesFunction(): Code;
+    protected get inlineValueSparqlWherePatternsFunction(): Code;
+    protected get inlineToJsonFunction(): Code;
+    protected get inlineToRdfResourceValuesFunction(): Code;
+    protected get schemaObject(): {
+        kind: Code;
+        members: Code;
+    };
+    jsonUiSchemaElement(): Maybe<Code>;
+    protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+}
+type Discriminant = EnvelopeDiscriminant | InlineDiscriminant | TypeofDiscriminant;
+type EnvelopeDiscriminant = {
+    kind: "envelope";
+} & AbstractType.DiscriminantProperty;
+type InlineDiscriminant = {
+    kind: "inline";
+} & AbstractType.DiscriminantProperty;
+type TypeofDiscriminant = {
+    kind: "typeof";
+};
+export declare namespace Discriminant {
+    function infer(memberTypes: readonly Type[]): Discriminant;
+}
+export declare namespace AbstractUnionType {
+    interface AbstractMember<TypeT extends Type> {
+        readonly abstract: true;
+        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly type: TypeT;
+    }
+    interface ConcreteMember<TypeT extends Type> {
+        readonly abstract: false;
+        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly jsonTypeCheck: (instance: Code) => Code;
+        readonly primaryDiscriminantValue: AbstractType.DiscriminantProperty.Value;
+        readonly type: TypeT;
+        readonly typeCheck: (instance: Code) => Code;
+        readonly unwrap: (instance: Code) => Code;
+        readonly wrap: (instance: Code) => Code;
+    }
+    type Member<TypeT extends Type> = AbstractMember<TypeT> | ConcreteMember<TypeT>;
+}
+export {};
+//# sourceMappingURL=AbstractUnionType.d.ts.map