@shaclmate/compiler 4.0.29 → 4.0.31

package/dist/generators/ts/OptionType.js

@@ -10,8 +10,6 @@ import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
@@ -22,14 +20,14 @@ export class OptionType extends AbstractContainerType {
         const conversions = [];
         conversions.push({
             conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
+            sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
             sourceTypeName: this.name,
             sourceTypeof: "object",
         });
         for (const itemTypeConversion of this.itemType.conversions) {
             conversions.push({
                 ...itemTypeConversion,
-                conversionExpression: (value) => code `${imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
+                conversionExpression: (value) => code `${this.reusables.imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
             });
         }
         // Unless itemType is a list, it should only have a conversion from undefined if it has a
@@ -38,7 +36,7 @@ export class OptionType extends AbstractContainerType {
         invariant(!conversions.some((conversion) => conversion.sourceTypeof === "undefined") || this.itemType instanceof AbstractCollectionType);
         if (!conversions.some((conversion) => conversion.sourceTypeof === "undefined")) {
             conversions.push({
-                conversionExpression: () => code `${imports.Maybe}.empty()`,
+                conversionExpression: () => code `${this.reusables.imports.Maybe}.empty()`,
                 sourceTypeCheckExpression: (value) => code `${value} === undefined`,
                 sourceTypeName: code `undefined`,
                 sourceTypeof: "undefined",
@@ -47,17 +45,17 @@ export class OptionType extends AbstractContainerType {
         return conversions;
     }
     get equalsFunction() {
-        return code `((left, right) => ${snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
+        return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
     get filterFunction() {
-        return code `${snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
     get filterType() {
-        return code `${snippets.MaybeFilter}<${this.itemType.filterType}>`;
+        return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
-        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, {
+        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, this.reusables, {
             nullable: true,
         });
     }
@@ -65,16 +63,16 @@ export class OptionType extends AbstractContainerType {
         return this.itemType.mutable;
     }
     get name() {
-        return code `${imports.Maybe}<${this.itemType.name}>`;
+        return code `${this.reusables.imports.Maybe}<${this.itemType.name}>`;
     }
     get schemaType() {
-        return code `${snippets.MaybeSchema}<${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -83,7 +81,7 @@ export class OptionType extends AbstractContainerType {
         };
     }
     fromJsonExpression({ variables, }) {
-        const expression = code `${imports.Maybe}.fromNullable(${variables.value})`;
+        const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
         const valueVariable = code `item`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
             variables: { value: valueVariable },
@@ -94,7 +92,7 @@ export class OptionType extends AbstractContainerType {
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
+        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${this.reusables.imports.Maybe}.of(value)) : ${this.reusables.imports.Resource}.Values.fromValue<${this.reusables.imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${this.reusables.imports.Maybe}.empty() }))`;
     }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;

package/dist/generators/ts/Reusables.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "ts-log";
+import { Imports } from "./Imports.js";
+import { Snippets } from "./Snippets.js";
+export declare class Reusables {
+    readonly imports: Imports;
+    readonly snippets: Snippets;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+}
+//# sourceMappingURL=Reusables.d.ts.map

package/dist/generators/ts/Reusables.js

@@ -0,0 +1,14 @@
+import { Imports } from "./Imports.js";
+import { Snippets } from "./Snippets.js";
+export class Reusables {
+    imports;
+    snippets;
+    constructor({ logger }) {
+        this.imports = new Imports();
+        this.snippets = new Snippets({
+            imports: this.imports,
+            logger,
+        });
+    }
+}
+//# sourceMappingURL=Reusables.js.map

package/dist/generators/ts/SetType.js

@@ -7,8 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
@@ -26,10 +24,10 @@ export class SetType extends AbstractCollectionType {
         return conversions.concat(super.conversions);
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -40,9 +38,9 @@ export class SetType extends AbstractCollectionType {
             chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
         else {
-            chain.push(code `chain(values => ${imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
+            chain.push(code `chain(values => ${this.reusables.imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
         }
-        chain.push(code `map(valuesArray => ${imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
+        chain.push(code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
         return joinCode(chain, { on: "." });
     }
     jsonType() {

package/dist/generators/ts/Snippet.d.ts

@@ -0,0 +1,3 @@
+import type { conditionalOutput } from "./ts-poet-wrapper.js";
+export type Snippet = ReturnType<typeof conditionalOutput>;
+//# sourceMappingURL=Snippet.d.ts.map

package/dist/generators/ts/Snippet.js

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

package/dist/generators/ts/SnippetFactory.d.ts

@@ -0,0 +1,14 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
+import type { Logger } from "ts-log";
+import type { Imports } from "./Imports.js";
+import type { Snippet } from "./Snippet.js";
+import type { Snippets } from "./Snippets.js";
+import type { Code } from "./ts-poet-wrapper.js";
+export type SnippetFactory = (parameters: {
+    imports: Imports;
+    logger: Logger;
+    rdfjsTermExpression: (rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">) => Code;
+    snippets: Snippets;
+    syntheticNamePrefix: string;
+}) => Snippet;
+//# sourceMappingURL=SnippetFactory.d.ts.map

package/dist/generators/ts/SnippetFactory.js

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

package/dist/generators/ts/Snippets.d.ts

@@ -0,0 +1,126 @@
+import type { Logger } from "ts-log";
+import type { Imports } from "./Imports.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class Snippets {
+    protected readonly imports: Imports;
+    protected readonly logger: Logger;
+    constructor({ imports, logger }: {
+        imports: Imports;
+        logger: Logger;
+    });
+    get BlankNodeFilter(): Snippet;
+    get BlankNodeSchema(): Snippet;
+    get BooleanFilter(): Snippet;
+    get BooleanSchema(): Snippet;
+    get CollectionFilter(): Snippet;
+    get CollectionSchema(): Snippet;
+    get DateFilter(): Snippet;
+    get DateSchema(): Snippet;
+    get DefaultValueSchema(): Snippet;
+    get EqualsResult(): Snippet;
+    get FocusSparqlConstructTriplesFunction(): Snippet;
+    get FocusSparqlWherePatternsFunction(): Snippet;
+    get FromRdfResourceFunction(): Snippet;
+    get FromRdfResourceValuesFunction(): Snippet;
+    get Hasher(): Snippet;
+    get IdentifierFilter(): Snippet;
+    get IdentifierSchema(): Snippet;
+    get IdentifierSet(): Snippet;
+    get IriFilter(): Snippet;
+    get IriSchema(): Snippet;
+    get LazyObject(): Snippet;
+    get LazyObjectOption(): Snippet;
+    get LazyObjectSet(): Snippet;
+    get LiteralFilter(): Snippet;
+    get LiteralSchema(): Snippet;
+    get MaybeFilter(): Snippet;
+    get MaybeSchema(): Snippet;
+    get NumericFilter(): Snippet;
+    get NumericSchema(): Snippet;
+    get PropertyPath(): Snippet;
+    get RdfVocabularies(): Snippet;
+    get ShaclPropertySchema(): Snippet;
+    get SparqlFilterPattern(): Snippet;
+    get SparqlPattern(): Snippet;
+    get SparqlPattern_isSolutionGenerating(): Snippet;
+    get StringFilter(): Snippet;
+    get StringSchema(): Snippet;
+    get TermFilter(): Snippet;
+    get TermSchema(): Snippet;
+    get ToRdfResourceFunction(): Snippet;
+    get ToRdfResourceValuesFunction(): Snippet;
+    get UnwrapR(): Snippet;
+    get ValueSparqlConstructTriplesFunction(): Snippet;
+    get ValueSparqlWherePatternsFunction(): Snippet;
+    get _FromRdfResourceFunction(): Snippet;
+    get _ToRdfResourceFunction(): Snippet;
+    get arrayEquals(): Snippet;
+    get arrayIntersection(): Snippet;
+    get bigDecimalLiteral(): Snippet;
+    get bigDecimalSparqlWherePatterns(): Snippet;
+    get blankNodeSparqlWherePatterns(): Snippet;
+    get booleanEquals(): Snippet;
+    get booleanSparqlWherePatterns(): Snippet;
+    get compactRecord(): Snippet;
+    get dateEquals(): Snippet;
+    get dateSparqlWherePatterns(): Snippet;
+    get decodeBigDecimalLiteral(): Snippet;
+    get deduplicateSparqlPatterns(): Snippet;
+    get defaultValueSparqlWherePatterns(): Snippet;
+    get filterArray(): Snippet;
+    get filterBigDecimal(): Snippet;
+    get filterBlankNode(): Snippet;
+    get filterBoolean(): Snippet;
+    get filterDate(): Snippet;
+    get filterIdentifier(): Snippet;
+    get filterIri(): Snippet;
+    get filterLiteral(): Snippet;
+    get filterMaybe(): Snippet;
+    get filterNumeric(): Snippet;
+    get filterString(): Snippet;
+    get filterTerm(): Snippet;
+    get fromRdfLanguageIn(): Snippet;
+    get fromRdfPreferredLanguages(): Snippet;
+    get identifierSparqlWherePatterns(): Snippet;
+    get ifUsed(): Code[];
+    get iriSparqlWherePatterns(): Snippet;
+    get isReadonlyBigIntArray(): Snippet;
+    get isReadonlyBooleanArray(): Snippet;
+    get isReadonlyNumberArray(): Snippet;
+    get isReadonlyObjectArray(): Snippet;
+    get isReadonlyStringArray(): Snippet;
+    get liftSparqlPatterns(): Snippet;
+    get listSparqlConstructTriples(): Snippet;
+    get listSparqlWherePatterns(): Snippet;
+    get literalFactory(): Snippet;
+    get literalSchemaSparqlPatterns(): Snippet;
+    get literalSparqlWherePatterns(): Snippet;
+    get maybeEquals(): Snippet;
+    get maybeSparqlConstructTriples(): Snippet;
+    get maybeSparqlWherePatterns(): Snippet;
+    get normalizeSparqlWherePatterns(): Snippet;
+    get numericSparqlWherePatterns(): Snippet;
+    get parseBlankNode(): Snippet;
+    get parseIdentifier(): Snippet;
+    get parseIri(): Snippet;
+    get setSparqlConstructTriples(): Snippet;
+    get setSparqlWherePatterns(): Snippet;
+    get shaclPropertyFromRdf(): Snippet;
+    get shaclPropertySparqlConstructTriples(): Snippet;
+    get shaclPropertySparqlWherePatterns(): Snippet;
+    get sortSparqlPatterns(): Snippet;
+    get sparqlInstancesOfPattern(): Snippet;
+    get sparqlPropertyPath(): Snippet;
+    get sparqlValueInPattern(): Snippet;
+    get strictEquals(): Snippet;
+    get stringSparqlWherePatterns(): Snippet;
+    get termFilterSparqlPatterns(): Snippet;
+    get termSchemaSparqlPatterns(): Snippet;
+    get termSparqlWherePatterns(): Snippet;
+    get wrap_FromRdfResourceFunction(): Snippet;
+    get wrap_ToRdfResourceFunction(): Snippet;
+    protected get snippets(): Snippets;
+    private snippet;
+}
+//# sourceMappingURL=Snippets.d.ts.map