@shaclmate/compiler 4.0.26 → 4.0.28

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -82,19 +82,19 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
     return transformShapeToAstType
         .call(this, propertyShape, shapeStack)
         .chain((propertyShapeAstType) => {
-        let maxCount = propertyShape.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
-        let minCount = propertyShape.minCount.orDefault(0);
-        if (minCount < 0) {
-            minCount = 0;
+        let maxCount = propertyShape.maxCount.orDefault(BigInt(Number.MAX_SAFE_INTEGER));
+        let minCount = propertyShape.minCount.orDefault(0n);
+        if (minCount < 0n) {
+            minCount = 0n;
         }
         if (propertyShape.hasValues.length > minCount) {
-            minCount = propertyShape.hasValues.length;
+            minCount = BigInt(propertyShape.hasValues.length);
         }
         if (maxCount < minCount) {
             maxCount = minCount;
         }
         if (propertyShapeAstType.kind === "DefaultValueType") {
-            if (minCount > 0) {
+            if (minCount > 0n) {
                 return Left(new Error(`${propertyShape}: has sh:minCount > 0 and sh:defaultValue`));
             }
             if (maxCount > 1) {
@@ -102,10 +102,10 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
             }
             return Either.of(propertyShapeAstType);
         }
-        if (minCount === 1 && maxCount === 1) {
+        if (minCount === 1n && maxCount === 1n) {
             return Either.of(propertyShapeAstType);
         }
-        if (minCount === 0 && maxCount === 1) {
+        if (minCount === 0n && maxCount === 1n) {
             if (!ast.OptionType.isItemType(propertyShapeAstType)) {
                 return Left(new Error(`${propertyShape}: ${propertyShapeAstType} is not an OptionType item type`));
             }
@@ -228,12 +228,12 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                         ...astAbstractTypeProperties,
                         partialType: new ast.SetType({
                             itemType: astPartialItemType,
-                            minCount: 0,
+                            minCount: 0n,
                             mutable: false,
                         }),
                         resolveType: new ast.SetType({
                             itemType: astResolveItemType,
-                            minCount: 0,
+                            minCount: 0n,
                             mutable: false,
                         }),
                     });

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -11,13 +11,13 @@ import { transformShapeToAstType } from "./transformShapeToAstType.js";
 export function transformShapeToAstCompoundType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain4(Either.sequence(shape.and
+        return Eithers.chain3(Either.sequence(shape.and
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.nodes.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), shape.$type === "NodeShape"
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), shape.$type === "NodeShape"
             ? nodeShapeTsFeatures.call(this, shape)
             : Either.of(new Set()), Either.sequence(shape.xone
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, tsFeatures, xoneConstraintShapes]) => {
             let compoundTypeKind;
             // Distinguish constraints that take arbitrary shapes from those that only take node shapes
             // With the latter we'll do special transformations.
@@ -26,10 +26,6 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 memberShapes = andConstraintShapes;
                 compoundTypeKind = "IntersectionType";
             }
-            else if (nodeConstraintShapes.length > 0) {
-                memberShapes = nodeConstraintShapes;
-                compoundTypeKind = "IntersectionType";
-            }
             else if (xoneConstraintShapes.length > 0) {
                 memberShapes = xoneConstraintShapes;
                 compoundTypeKind = "UnionType";

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -92,15 +92,15 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     if (!firstPropertyShape) {
                         return empty;
                     }
-                    if (firstPropertyShape.maxCount.extract() !== 1 ||
-                        firstPropertyShape.minCount.extract() !== 1) {
+                    if (firstPropertyShape.maxCount.extract() !== 1n ||
+                        firstPropertyShape.minCount.extract() !== 1n) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     if (!restPropertyShape) {
                         return empty;
                     }
-                    if (restPropertyShape.maxCount.extract() !== 1 ||
-                        restPropertyShape.minCount.extract() !== 1) {
+                    if (restPropertyShape.maxCount.extract() !== 1n ||
+                        restPropertyShape.minCount.extract() !== 1n) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:rest property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     return transformPropertyShapeToAstObjectTypeProperty

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.d.ts

@@ -3,5 +3,5 @@ import * as ast from "../ast/index.js";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import { ShapeStack } from "./ShapeStack.js";
-export declare function transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ObjectType>>;
+export declare function transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
 //# sourceMappingURL=transformShapeToAstObjectType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -17,7 +17,7 @@ function isObjectTypePropertyRequired(property) {
         case "LazyObjectOptionType":
             return false;
         case "LazyObjectSetType":
-            return property.type.partialType.minCount > 0;
+            return property.type.partialType.minCount > 0n;
         case "OptionType":
             return false;
         case "SetType":
@@ -43,6 +43,12 @@ function isObjectTypePropertyRequired(property) {
 export function transformShapeToAstObjectType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
+        if (shape.node.isJust()) {
+            return this.shapesGraph
+                .nodeShape(shape.node.unsafeCoerce())
+                .chain((nodeShape) => transformShapeToAstType.call(this, nodeShape, shapeStack))
+                .map(Maybe.of);
+        }
         if (shape.$type !== "NodeShape") {
             return Either.of(Maybe.empty());
         }

package/dist/ast/SetType.d.ts

@@ -7,9 +7,9 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
     /**
      * Minimum number of items in the set.
      */
-    readonly minCount: number;
+    readonly minCount: bigint;
     constructor({ itemType, minCount, ...superParameters }: {
-        minCount: number;
+        minCount: bigint;
     } & Pick<ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0], "itemType" | "mutable">);
     equals(other: SetType<ItemTypeT>): boolean;
     toJSON(): {

package/dist/ast/SetType.js

@@ -31,7 +31,7 @@ export class SetType extends AbstractCollectionType {
     toJSON() {
         return {
             ...super.toJSON(),
-            minCount: this.minCount,
+            minCount: Number(this.minCount),
         };
     }
 }

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -6,12 +6,12 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     protected readonly _mutable: boolean;
-    protected readonly minCount: number;
+    protected readonly minCount: bigint;
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     readonly typeofs: NonEmptyList<"object">;
     constructor({ minCount, mutable, ...superParameters }: {
-        minCount: number;
+        minCount: bigint;
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get conversions(): readonly AbstractContainerType.Conversion[];

package/dist/generators/ts/AbstractCollectionType.js

@@ -24,10 +24,10 @@ export class AbstractCollectionType extends AbstractContainerType {
     constructor({ minCount, mutable, ...superParameters }) {
         super(superParameters);
         this.minCount = minCount;
-        invariant(this.minCount >= 0);
+        invariant(this.minCount >= 0n);
         this._mutable = mutable;
         if (mutable) {
-            invariant(this.minCount === 0);
+            invariant(this.minCount === 0n);
         }
     }
     get conversions() {
@@ -54,7 +54,7 @@ export class AbstractCollectionType extends AbstractContainerType {
                 }
             }
         }
-        if (this.minCount === 0) {
+        if (this.minCount === 0n) {
             if (Object.keys(itemTypeConversionsByTypeof).length <= 1) {
                 // There were no additional conversions with different item typeof's, so we don't need to check .every or do .map
                 // Just check that the original value is an array with typeof "object". Array.isArray() doesn't narrow types for some reason.
@@ -135,7 +135,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         if (this._mutable) {
             return code `(${this.itemType.name})[]`;
         }
-        if (this.minCount === 0) {
+        if (this.minCount === 0n) {
             return code `readonly (${this.itemType.name})[]`;
         }
         return code `${imports.NonEmptyList}<${this.itemType.name}>`;
@@ -146,15 +146,15 @@ export class AbstractCollectionType extends AbstractContainerType {
     get schemaObject() {
         return {
             ...super.schemaObject,
-            minCount: this.minCount > 0 ? this.minCount : undefined,
+            minCount: this.minCount > 0n ? Number(this.minCount) : undefined,
         };
     }
     fromJsonExpression({ variables, }) {
         let expression = variables.value;
-        if (!this._mutable && this.minCount > 0) {
+        if (!this._mutable && this.minCount > 0n) {
             expression = code `${imports.NonEmptyList}.fromArray(${expression}).unsafeCoerce()`;
         }
-        if (this.minCount === 0) {
+        if (this.minCount === 0n) {
             expression = code `(${expression} ?? [])`;
         }
         const valueVariable = code `item`;
@@ -186,7 +186,7 @@ export class AbstractCollectionType extends AbstractContainerType {
     }
     jsonSchema(parameters) {
         let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
-        if (this.minCount > 0) {
+        if (this.minCount > 0n) {
             schema = code `${schema}.nonempty().min(${this.minCount})`;
         }
         else {

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -26,6 +26,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     protected abstract literalOf(value: ValueT): string;
 }
 export declare namespace AbstractNumericType {
+    type Conversion = AbstractPrimitiveType.Conversion;
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
     type JsonType = AbstractPrimitiveType.JsonType;
 }

package/dist/generators/ts/BigIntType.d.ts

@@ -5,6 +5,7 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BigIntType";
     readonly typeofs: NonEmptyList<"bigint">;
+    get conversions(): readonly AbstractNumericType.Conversion[];
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;

package/dist/generators/ts/BigIntType.js

@@ -13,6 +13,17 @@ export class BigIntType extends AbstractNumericType {
     graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLBigInt}`);
     kind = "BigIntType";
     typeofs = NonEmptyList(["bigint"]);
+    get conversions() {
+        if (this.in_.length > 0) {
+            return super.conversions;
+        }
+        return super.conversions.concat({
+            conversionExpression: (value) => code `BigInt(${value})`,
+            sourceTypeCheckExpression: (value) => code `typeof ${value} === "number"`,
+            sourceTypeName: "number",
+            sourceTypeof: "number",
+        });
+    }
     fromJsonExpression({ variables, }) {
         let expression = code `BigInt(${variables.value})`;
         if (this.primitiveIn.length > 0) {

package/dist/generators/ts/SetType.js

@@ -15,7 +15,7 @@ export class SetType extends AbstractCollectionType {
     kind = "SetType";
     get conversions() {
         const conversions = [];
-        if (this.minCount === 0) {
+        if (this.minCount === 0n) {
             conversions.push({
                 conversionExpression: () => code `[]`,
                 sourceTypeCheckExpression: (value) => code `${value} === undefined`,
@@ -36,7 +36,7 @@ export class SetType extends AbstractCollectionType {
         const chain = [
             this.itemType.fromRdfResourceValuesExpression(parameters),
         ];
-        if (this.minCount === 0 || this._mutable) {
+        if (this.minCount === 0n || this._mutable) {
             chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
         else {
@@ -47,7 +47,7 @@ export class SetType extends AbstractCollectionType {
     }
     jsonType() {
         const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;
-        if (this.minCount === 0) {
+        if (this.minCount === 0n) {
             return new AbstractCollectionType.JsonType(name, { optional: true });
         }
         return new AbstractCollectionType.JsonType(name);

package/dist/generators/ts/TypeFactory.js

@@ -281,7 +281,7 @@ export class TypeFactory {
             itemType,
             label: astType.label,
             logger: this.logger,
-            minCount: 0,
+            minCount: 0n,
             mutable: astType.mutable,
             toRdfTypes: astType.toRdfTypes,
         });
@@ -394,9 +394,9 @@ export class TypeFactory {
         else if (datatypes.size > 0) {
             this.logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
         }
-        else {
-            this.logger.debug("literal type has no datatypes");
-        }
+        // } else {
+        //   // this.logger.debug("literal type has no datatypes");
+        // }
         return new LiteralType({
             comment: astType.comment,
             hasValues: astType.hasValues,