ldkit 0.0.3 → 0.4.1

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

@@ -0,0 +1,38 @@
+declare const _default: {
+    Collection: "skos:Collection";
+    member: "skos:member";
+    Concept: "skos:Concept";
+    ConceptScheme: "skos:ConceptScheme";
+    OrderedCollection: "skos:OrderedCollection";
+    altLabel: "skos:altLabel";
+    broadMatch: "skos:broadMatch";
+    broader: "skos:broader";
+    broaderTransitive: "skos:broaderTransitive";
+    changeNote: "skos:changeNote";
+    closeMatch: "skos:closeMatch";
+    definition: "skos:definition";
+    editorialNote: "skos:editorialNote";
+    exactMatch: "skos:exactMatch";
+    example: "skos:example";
+    hasTopConcept: "skos:hasTopConcept";
+    hiddenLabel: "skos:hiddenLabel";
+    historyNote: "skos:historyNote";
+    inScheme: "skos:inScheme";
+    mappingRelation: "skos:mappingRelation";
+    memberList: "skos:memberList";
+    narrowMatch: "skos:narrowMatch";
+    narrower: "skos:narrower";
+    narrowerTransitive: "skos:narrowerTransitive";
+    notation: "skos:notation";
+    note: "skos:note";
+    prefLabel: "skos:prefLabel";
+    related: "skos:related";
+    relatedMatch: "skos:relatedMatch";
+    scopeNote: "skos:scopeNote";
+    semanticRelation: "skos:semanticRelation";
+    topConceptOf: "skos:topConceptOf";
+} & {
+    $prefix: "skos:";
+    $iri: "http://www.w3.org/2004/02/skos/core#";
+};
+export default _default;

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

@@ -0,0 +1,56 @@
+declare const _default: {
+    string: "xsd:string";
+    boolean: "xsd:boolean";
+    language: "xsd:language";
+    date: "xsd:date";
+    duration: "xsd:duration";
+    ENTITIES: "xsd:ENTITIES";
+    ENTITY: "xsd:ENTITY";
+    ID: "xsd:ID";
+    IDREF: "xsd:IDREF";
+    IDREFS: "xsd:IDREFS";
+    NCName: "xsd:NCName";
+    NMTOKEN: "xsd:NMTOKEN";
+    NMTOKENS: "xsd:NMTOKENS";
+    NOTATION: "xsd:NOTATION";
+    Name: "xsd:Name";
+    QName: "xsd:QName";
+    anyAtomicType: "xsd:anyAtomicType";
+    anySimpleType: "xsd:anySimpleType";
+    anyType: "xsd:anyType";
+    anyURI: "xsd:anyURI";
+    base64Binary: "xsd:base64Binary";
+    byte: "xsd:byte";
+    dateTime: "xsd:dateTime";
+    dateTimeStamp: "xsd:dateTimeStamp";
+    dayTimeDuration: "xsd:dayTimeDuration";
+    decimal: "xsd:decimal";
+    double: "xsd:double";
+    float: "xsd:float";
+    gDay: "xsd:gDay";
+    gMonth: "xsd:gMonth";
+    gMonthDay: "xsd:gMonthDay";
+    gYear: "xsd:gYear";
+    gYearMonth: "xsd:gYearMonth";
+    hexBinary: "xsd:hexBinary";
+    int: "xsd:int";
+    integer: "xsd:integer";
+    long: "xsd:long";
+    negativeInteger: "xsd:negativeInteger";
+    nonNegativeInteger: "xsd:nonNegativeInteger";
+    nonPositiveInteger: "xsd:nonPositiveInteger";
+    normalizedString: "xsd:normalizedString";
+    positiveInteger: "xsd:positiveInteger";
+    short: "xsd:short";
+    time: "xsd:time";
+    token: "xsd:token";
+    unsignedByte: "xsd:unsignedByte";
+    unsignedInt: "xsd:unsignedInt";
+    unsignedLong: "xsd:unsignedLong";
+    unsignedShort: "xsd:unsignedShort";
+    yearMonthDuration: "xsd:yearMonthDuration";
+} & {
+    $prefix: "xsd:";
+    $iri: "http://www.w3.org/2001/XMLSchema#";
+};
+export default _default;

package/types/library/rdf.d.ts

@@ -0,0 +1,14 @@
+import type { NamedNode, BlankNode, Literal, Variable, Quad, Term, Bindings } from "rdf-js";
+export type { NamedNode, BlankNode, Literal, Variable, Quad, Term, Bindings };
+export { fromRdf, toRdf } from "rdf-literal";
+import * as DataFactory from "rdf-data-factory";
+export { DataFactory } from "rdf-data-factory";
+export declare type Iri = string;
+export declare type Node = Map<Iri, Term[]>;
+export declare type Graph = Map<Iri, Node>;
+export declare const namedNode: <Iri_1 extends string = string>(value: Iri_1) => NamedNode<Iri_1>;
+export declare const blankNode: (value: string) => DataFactory.BlankNode;
+export declare const literal: (value: string, languageOrDatatype?: string | NamedNode) => Literal;
+export declare const quad: (subject: Quad["subject"], predicate: Quad["predicate"], object: Quad["object"], graph?: Quad["graph"]) => Quad;
+export declare const variable: (value: string) => Variable;
+export declare const quadsToGraph: (quads: Quad[]) => Graph;

package/types/library/resource/mod.d.ts

@@ -0,0 +1 @@
+export { createResource, Resource } from "./resource.js";

package/types/library/resource/query_builder.d.ts

@@ -0,0 +1,22 @@
+import type { Schema } from "../schema/mod.js";
+import { Quad, Iri } from "../rdf.js";
+import type { Context } from "../context.js";
+import type { Entity } from "./types.js";
+export declare class QueryBuilder {
+    private readonly schema;
+    private readonly schemaProperties;
+    private readonly context;
+    constructor(schema: Schema, context: Context);
+    private getResourceSignature;
+    private getTypesSignature;
+    private entitiesToQuads;
+    private getShape;
+    countQuery(): string;
+    getQuery(where?: string | Quad[], limit?: number): string;
+    getByIrisQuery(iris: Iri[]): string;
+    insertQuery(entities: Entity[]): string;
+    insertDataQuery(quads: Quad[]): string;
+    deleteQuery: (iris: Iri[]) => string;
+    deleteDataQuery(quads: Quad[]): string;
+    updateQuery(entities: Entity[]): string;
+}

package/types/library/resource/query_helper.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from "../context.js";
+import type { Schema } from "../schema/mod.js";
+import type { Quad } from "../rdf.js";
+import type { Entity } from "./types.js";
+export declare class QueryHelper {
+    private readonly entity;
+    private readonly schema;
+    private readonly context;
+    private readonly variableInitCounter;
+    private quads?;
+    private variableQuads?;
+    constructor(entity: Entity, schema: Schema, context: Context, variableInitCounter?: number);
+    getQuads(): Quad[];
+    getVariableQuads(): Quad[];
+    getDeleteQuads(): Quad[];
+    getInsertQuads(): Quad[];
+    getWhereQuads(): Quad[];
+    private getEntityWithReplacedVariables;
+    private replaceVariables;
+}

package/types/library/resource/resource.d.ts

@@ -0,0 +1,24 @@
+import type { Iri, Quad } from "../rdf.js";
+import { type Context } from "../context.js";
+import { type SchemaPrototype, type SchemaInterface, type SchemaInterfaceIdentity } from "../schema/mod.js";
+import type { Entity } from "./types.js";
+export declare const createResource: <T extends SchemaPrototype>(spec: T, context?: Context) => Resource<T, SchemaInterface<T>>;
+export declare class Resource<S extends SchemaPrototype, I = SchemaInterface<S>> {
+    private readonly schema;
+    private readonly context;
+    private readonly queryBuilder;
+    private readonly $trigger;
+    constructor(schema: S, context?: Context);
+    private decode;
+    count(): import("rxjs/internal/Observable").Observable<number>;
+    query(sparqlConstructQuery: string): import("rxjs/internal/Observable").Observable<I[]>;
+    find(where?: string | Quad[], limit?: number): import("rxjs/internal/Observable").Observable<I[]>;
+    findByIri(iri: Iri): import("rxjs/internal/Observable").Observable<I | undefined>;
+    findByIris(iris: Iri[]): import("rxjs/internal/Observable").Observable<I[]>;
+    private updateQuery;
+    insert(...entities: Entity<I>[]): import("rxjs/internal/Observable").Observable<void>;
+    insertData(...quads: Quad[]): import("rxjs/internal/Observable").Observable<void>;
+    update(...entities: Entity<I>[]): import("rxjs/internal/Observable").Observable<void>;
+    delete(...identities: SchemaInterfaceIdentity[] | Iri[]): import("rxjs/internal/Observable").Observable<void>;
+    deleteData(...quads: Quad[]): import("rxjs/internal/Observable").Observable<void>;
+}

package/types/library/resource/types.d.ts

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

package/types/library/rxjs.d.ts

@@ -0,0 +1,2 @@
+export { type Observable, from, BehaviorSubject, } from "rxjs";
+export { map, switchMap, tap, share, } from "rxjs/operators";

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

@@ -0,0 +1,39 @@
+declare const SupportedDataTypesPrototype: {
+    "xsd:dateTime": Date;
+    "xsd:date": Date;
+    "xsd:gDay": Date;
+    "xsd:gMonthDay": Date;
+    "xsd:gYear": Date;
+    "xsd:gYearMonth": Date;
+    "xsd:boolean": boolean;
+    "xsd:double": number;
+    "xsd:decimal": number;
+    "xsd:float": number;
+    "xsd:integer": number;
+    "xsd:long": number;
+    "xsd:int": number;
+    "xsd:byte": number;
+    "xsd:short": number;
+    "xsd:negativeInteger": number;
+    "xsd:nonNegativeInteger": number;
+    "xsd:nonPositiveInteger": number;
+    "xsd:positiveInteger": number;
+    "xsd:unsignedByte": number;
+    "xsd:unsignedInt": number;
+    "xsd:unsignedLong": number;
+    "xsd:unsignedShort": number;
+    "xsd:string": string;
+    "xsd:normalizedString": string;
+    "xsd:anyURI": string;
+    "xsd:base64Binary": string;
+    "xsd:language": string;
+    "xsd:Name": string;
+    "xsd:NCName": string;
+    "xsd:NMTOKEN": string;
+    "xsd:token": string;
+    "xsd:hexBinary": string;
+    "rdf:langString": string;
+};
+export declare type SupportedDataTypes = typeof SupportedDataTypesPrototype;
+export declare type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
+export {};

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

@@ -0,0 +1,32 @@
+import type { SupportedDataTypes } from "./data_types.js";
+import type { SchemaPrototype, PropertyPrototype } from "./schema.js";
+declare type IsOptional<Property extends PropertyPrototype> = Property extends {
+    "@optional": true;
+} ? true : false;
+declare type IsArray<Property extends PropertyPrototype> = Property extends {
+    "@array": true;
+} ? true : false;
+declare type IsMultilang<Property extends PropertyPrototype> = Property extends {
+    "@multilang": true;
+} ? true : false;
+declare type ValidPropertyDefinition = PropertyPrototype | string;
+declare type ConvertPropertyType<T extends PropertyPrototype> = T extends {
+    "@context": SchemaPrototype;
+} ? SchemaInterface<T["@context"]> : T extends {
+    "@type": any;
+} ? 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 = {
+    $id: string;
+};
+export declare type SchemaInterfaceType = {
+    $type: string[];
+};
+export declare 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/mod.d.ts

@@ -0,0 +1,3 @@
+export type { SchemaInterface, SchemaInterfaceIdentity, SchemaInterfaceType, } from "./interface.js";
+export type { Schema, SchemaPrototype, Property, PropertyPrototype, } from "./schema.js";
+export { expandSchema, getSchemaProperties } from "./utils.js";

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

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

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

@@ -0,0 +1,3 @@
+import type { Property, Schema, SchemaPrototype } from "./schema.js";
+export declare const expandSchema: (schemaPrototype: SchemaPrototype) => Schema;
+export declare const getSchemaProperties: (schema: Schema) => Record<string, Property>;

package/types/library/sparql.d.ts

@@ -0,0 +1,2 @@
+export { type SparqlTemplateResult, sparql as $, } from "@tpluscode/rdf-string";
+export { DELETE, INSERT, ASK, DESCRIBE, CONSTRUCT, SELECT, WITH, } from "@tpluscode/sparql-builder";

package/types/mod.d.ts

@@ -0,0 +1,4 @@
+export { type SchemaInterface } from "./library/schema/mod.js";
+export { createResource, type Resource } from "./library/resource/mod.js";
+export { createNamespace } from "./library/namespaces/namespace.js";
+export { type Context, createContext, createDefaultContext, } from "./library/context.js";

package/types/namespaces.d.ts

@@ -0,0 +1 @@
+export * from "./library/namespaces/mod.js";

package/types/rdf.d.ts

@@ -0,0 +1 @@
+export * from "./library/rdf.js";

package/types/sparql.d.ts

@@ -0,0 +1 @@
+export * from "./library/sparql.js";

package/esm/_dnt.shims.js

@@ -1,70 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-import { fetch, File, FormData, Headers, Request, Response } from "undici";
-export { fetch, File, FormData, Headers, Request, Response } from "undici";
-const dntGlobals = {
-    Deno,
-    fetch,
-    File,
-    FormData,
-    Headers,
-    Request,
-    Response,
-};
-export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-// deno-lint-ignore ban-types
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}