ldkit 0.7.0 → 0.8.0

package/esm/library/rdf.js

@@ -1,5 +1,5 @@
 export { fromRdf, toRdf } from "rdf-literal";
-import { DataFactory, DefaultGraph, } from "rdf-data-factory";
+import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
 export const quadsToGraph = (quads) => {
     const graph = new Map();

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -23,31 +23,51 @@
   },
   "exports": {
     ".": {
-      "import": "./esm/mod.js",
-      "require": "./script/mod.js",
-      "types": "./types/mod.d.ts"
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./esm/mod.js"
+      },
+      "require": {
+        "types": "./types/mod.d.ts",
+        "default": "./script/mod.js"
+      }
     },
     "./namespaces": {
-      "import": "./esm/namespaces.js",
-      "require": "./script/namespaces.js",
-      "types": "./types/namespaces.d.ts"
+      "import": {
+        "types": "./types/namespaces.d.ts",
+        "default": "./esm/namespaces.js"
+      },
+      "require": {
+        "types": "./types/namespaces.d.ts",
+        "default": "./script/namespaces.js"
+      }
     },
     "./rdf": {
-      "import": "./esm/rdf.js",
-      "require": "./script/rdf.js",
-      "types": "./types/rdf.d.ts"
+      "import": {
+        "types": "./types/rdf.d.ts",
+        "default": "./esm/rdf.js"
+      },
+      "require": {
+        "types": "./types/rdf.d.ts",
+        "default": "./script/rdf.js"
+      }
     },
     "./sparql": {
-      "import": "./esm/sparql.js",
-      "require": "./script/sparql.js",
-      "types": "./types/sparql.d.ts"
+      "import": {
+        "types": "./types/sparql.d.ts",
+        "default": "./esm/sparql.js"
+      },
+      "require": {
+        "types": "./types/sparql.d.ts",
+        "default": "./script/sparql.js"
+      }
     }
   },
   "dependencies": {
-    "@comunica/types": "2.4.0",
-    "asynciterator": "3.7.0",
+    "@comunica/types": "2.6.8",
+    "asynciterator": "3.8.0",
     "rdf-data-factory": "1.1.1",
     "rdf-js": "4.0.2",
-    "rdf-literal": "1.3.0"
+    "rdf-literal": "1.3.1"
   }
 }

package/types/library/asynciterator.d.ts

@@ -1,10 +1,10 @@
 import { AsyncIterator } from "asynciterator";
 export { ArrayIterator, type AsyncIterator, MappingIterator, } from "asynciterator";
-declare type TreeNode<T> = {
+type TreeNode<T> = {
     [property: string]: T[] | TreeNode<T>;
 };
-export declare type Tree<T> = T[] | TreeNode<T>;
-declare type Subtree<T> = {
+export type Tree<T> = T[] | TreeNode<T>;
+type Subtree<T> = {
     type: "node";
     tree: TreeNode<T>;
     parent?: Subtree<T>;

package/types/library/decoder.d.ts

@@ -1,5 +1,5 @@
 import { type Context, Graph } from "./rdf.js";
 import type { Schema } from "./schema/mod.js";
-declare type DecodedNode = Record<string, unknown>;
+type DecodedNode = Record<string, unknown>;
 export declare const decode: (graph: Graph, schema: Schema, context: Context) => DecodedNode[];
 export {};

package/types/library/encoder.d.ts

@@ -1,5 +1,5 @@
 import { type Context, type RDF } from "./rdf.js";
 import type { Schema } from "./schema/mod.js";
-declare type DecodedNode = Record<string, unknown>;
+type DecodedNode = Record<string, unknown>;
 export declare const encode: (node: DecodedNode, schema: Schema, context: Context, variableInitCounter?: number) => RDF.Quad[];
 export {};

package/types/library/engine/query_engine.d.ts

@@ -1,5 +1,5 @@
 import { type Context, type IQueryEngine, type RDF, RDFJSON } from "../rdf.js";
-declare type QueryResponseFormat = {
+type QueryResponseFormat = {
     "application/sparql-results+json": RDFJSON.SparqlResultsJsonFormat;
     "application/rdf+json": RDFJSON.RdfJsonFormat;
 };

package/types/library/lens/types.d.ts

@@ -1,5 +1,5 @@
 import type { SchemaInterfaceIdentity } from "../schema/mod.js";
-export declare type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & SchemaInterfaceIdentity;
-export declare type DeepPartial<T> = T extends Record<string, unknown> ? {
+export type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & SchemaInterfaceIdentity;
+export type DeepPartial<T> = T extends Record<string, unknown> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;

package/types/library/namespaces/namespace.d.ts

@@ -1,11 +1,11 @@
-declare type NamespacePrototype = {
+type NamespacePrototype = {
     iri: string;
     prefix: string;
     terms: readonly string[];
 };
-declare type NamespacePrefix<Namespace extends NamespacePrototype> = Namespace["prefix"];
-declare type NamespaceIri<Namespace extends NamespacePrototype> = Namespace["iri"];
-declare type NamespaceObject<Namespace extends NamespacePrototype> = {
+type NamespacePrefix<Namespace extends NamespacePrototype> = Namespace["prefix"];
+type NamespaceIri<Namespace extends NamespacePrototype> = Namespace["iri"];
+type NamespaceObject<Namespace extends NamespacePrototype> = {
     [Term in Namespace["terms"][number]]: `${NamespacePrefix<Namespace>}${Term}`;
 };
 export declare const createNamespace: <N extends NamespacePrototype, I = NamespaceIri<N>, P = NamespacePrefix<N>, O = NamespaceObject<N>>(namespaceSpec: N) => O & {

package/types/library/rdf.d.ts

@@ -4,15 +4,15 @@ export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
-export declare type LDkitContext = {
+export type LDkitContext = {
     graph?: string;
     language?: string;
 };
-export declare type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
-export declare type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
-export declare type Iri = string;
-export declare type Node = Map<Iri, RDF.Term[]>;
-export declare type Graph = Map<Iri, Node>;
+export type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
+export type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
+export type Iri = string;
+export type Node = Map<Iri, RDF.Term[]>;
+export type Graph = Map<Iri, Node>;
 export declare const quadsToGraph: (quads: RDF.Quad[]) => Graph;
 export declare namespace RDFJSON {
     type Term = {

package/types/library/schema/data_types.d.ts

@@ -34,6 +34,6 @@ declare const SupportedDataTypesPrototype: {
     "xsd:hexBinary": string;
     "rdf:langString": string;
 };
-export declare type SupportedDataTypes = typeof SupportedDataTypesPrototype;
-export declare type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
+export type SupportedDataTypes = typeof SupportedDataTypesPrototype;
+export type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
 export {};

package/types/library/schema/interface.d.ts

@@ -1,32 +1,32 @@
 import type { SupportedDataTypes } from "./data_types.js";
 import type { PropertyPrototype, SchemaPrototype } from "./schema.js";
-declare type IsOptional<Property extends PropertyPrototype> = Property extends {
+type IsOptional<Property extends PropertyPrototype> = Property extends {
     "@optional": true;
 } ? true : false;
-declare type IsArray<Property extends PropertyPrototype> = Property extends {
+type IsArray<Property extends PropertyPrototype> = Property extends {
     "@array": true;
 } ? true : false;
-declare type IsMultilang<Property extends PropertyPrototype> = Property extends {
+type IsMultilang<Property extends PropertyPrototype> = Property extends {
     "@multilang": true;
 } ? true : false;
-declare type ValidPropertyDefinition = PropertyPrototype | string;
-declare type ConvertPropertyType<T extends PropertyPrototype> = T extends {
+type ValidPropertyDefinition = PropertyPrototype | string;
+type ConvertPropertyType<T extends PropertyPrototype> = T extends {
     "@context": SchemaPrototype;
 } ? SchemaInterface<T["@context"]> : T extends {
     "@type": unknown;
 } ? T["@type"] extends keyof SupportedDataTypes ? SupportedDataTypes[T["@type"]] : never : string;
-declare type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
-declare type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
-declare type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
-declare type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
-declare type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
-export declare type SchemaInterfaceIdentity = {
+type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
+type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
+type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
+type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
+type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
+export type SchemaInterfaceIdentity = {
     $id: string;
 };
-export declare type SchemaInterfaceType = {
+export type SchemaInterfaceType = {
     $type: string[];
 };
-export declare type SchemaInterface<T extends SchemaPrototype> = {
+export type SchemaInterface<T extends SchemaPrototype> = {
     [X in Exclude<keyof T, "@type">]: T[X] extends ValidPropertyDefinition ? ConvertProperty<T[X]> : never;
 } & SchemaInterfaceIdentity & SchemaInterfaceType;
 export {};

package/types/library/schema/schema.d.ts

@@ -1,6 +1,6 @@
 import type { SupportedDataTypes } from "./data_types.js";
-declare type PropertyType = keyof SupportedDataTypes;
-export declare type PropertyPrototype = {
+type PropertyType = keyof SupportedDataTypes;
+export type PropertyPrototype = {
     "@id": string;
     "@type"?: PropertyType;
     "@context"?: SchemaPrototype;
@@ -8,14 +8,14 @@ export declare type PropertyPrototype = {
     "@array"?: true;
     "@multilang"?: true;
 };
-export declare type SchemaPrototypeProperties = {
+export type SchemaPrototypeProperties = {
     [key: string]: PropertyPrototype | string | readonly string[];
 };
-export declare type SchemaPrototypeType = {
+export type SchemaPrototypeType = {
     "@type": string | readonly string[];
 };
-export declare type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
-export declare type Property = {
+export type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
+export type Property = {
     "@id": string;
     "@type"?: PropertyType;
     "@context"?: Schema;
@@ -23,7 +23,7 @@ export declare type Property = {
     "@array"?: true;
     "@multilang"?: true;
 };
-export declare type Schema = {
+export type Schema = {
     [key: string]: Property | string[];
     "@type": string[];
 };

package/types/library/sparql/sparql_query_builders.d.ts

@@ -1,7 +1,7 @@
 import { SparqlBuilder } from "./sparql_shared_builders.js";
 import { type RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
-declare type Builders<T extends keyof SparqlQueryBuilder> = Pick<SparqlQueryBuilder, T>;
+type Builders<T extends keyof SparqlQueryBuilder> = Pick<SparqlQueryBuilder, T>;
 declare class SparqlQueryBuilder extends SparqlBuilder {
     OFFSET(number: number): Builders<"build">;
     LIMIT(number: number): Builders<"build" | "OFFSET">;

package/types/library/sparql/sparql_shared_builders.d.ts

@@ -1,6 +1,6 @@
 import { DataFactory, RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
-declare type Wrap = (keyword: string, value: string) => string;
+type Wrap = (keyword: string, value: string) => string;
 export declare const braces: Wrap;
 export declare const parentheses: Wrap;
 export declare abstract class SparqlBuilder {

package/types/library/sparql/sparql_tag.d.ts

@@ -1,3 +1,3 @@
 import { type RDF } from "../rdf.js";
-export declare type SparqlValue = RDF.Term | string | number | boolean | Date | Iterable<SparqlValue> | null | undefined;
+export type SparqlValue = RDF.Term | string | number | boolean | Date | Iterable<SparqlValue> | null | undefined;
 export declare const sparql: (strings: TemplateStringsArray, ...values: SparqlValue[]) => string;

package/types/library/sparql/sparql_update_builders.d.ts

@@ -1,7 +1,7 @@
 import { SparqlBuilder } from "./sparql_shared_builders.js";
 import { type RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
-declare type Builders<T extends keyof SparqlUpdateBuilder> = Pick<SparqlUpdateBuilder, T>;
+type Builders<T extends keyof SparqlUpdateBuilder> = Pick<SparqlUpdateBuilder, T>;
 declare class SparqlUpdateBuilder extends SparqlBuilder {
     WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
     USING_NAMED(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"USING_NAMED" | "WHERE">;