@ldo/jsonld-dataset-proxy 0.0.1-alpha.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +809 -0
- package/dist/ContextUtil.d.ts +12 -0
- package/dist/ContextUtil.js +70 -0
- package/dist/ContextUtil.js.map +1 -0
- package/dist/JsonldDatasetProxyBuilder.d.ts +15 -0
- package/dist/JsonldDatasetProxyBuilder.js +41 -0
- package/dist/JsonldDatasetProxyBuilder.js.map +1 -0
- package/dist/ProxyContext.d.ts +31 -0
- package/dist/ProxyContext.js +65 -0
- package/dist/ProxyContext.js.map +1 -0
- package/dist/arrayProxy/ArrayProxy.d.ts +12 -0
- package/dist/arrayProxy/ArrayProxy.js +3 -0
- package/dist/arrayProxy/ArrayProxy.js.map +1 -0
- package/dist/arrayProxy/arrayMethods.d.ts +17 -0
- package/dist/arrayProxy/arrayMethods.js +161 -0
- package/dist/arrayProxy/arrayMethods.js.map +1 -0
- package/dist/arrayProxy/createArrayHandler.d.ts +9 -0
- package/dist/arrayProxy/createArrayHandler.js +140 -0
- package/dist/arrayProxy/createArrayHandler.js.map +1 -0
- package/dist/arrayProxy/isArrayProxy.d.ts +2 -0
- package/dist/arrayProxy/isArrayProxy.js +17 -0
- package/dist/arrayProxy/isArrayProxy.js.map +1 -0
- package/dist/arrayProxy/modifyArray.d.ts +12 -0
- package/dist/arrayProxy/modifyArray.js +73 -0
- package/dist/arrayProxy/modifyArray.js.map +1 -0
- package/dist/graphOf.d.ts +3 -0
- package/dist/graphOf.js +37 -0
- package/dist/graphOf.js.map +1 -0
- package/dist/index.d.ts +32 -0
- package/dist/index.js +49 -0
- package/dist/index.js.map +1 -0
- package/dist/jsonldDatasetProxy.d.ts +4 -0
- package/dist/jsonldDatasetProxy.js +19 -0
- package/dist/jsonldDatasetProxy.js.map +1 -0
- package/dist/language/languageMapProxy.d.ts +4 -0
- package/dist/language/languageMapProxy.js +55 -0
- package/dist/language/languageMapProxy.js.map +1 -0
- package/dist/language/languageSet.d.ts +23 -0
- package/dist/language/languageSet.js +75 -0
- package/dist/language/languageSet.js.map +1 -0
- package/dist/language/languageTypes.d.ts +2 -0
- package/dist/language/languageTypes.js +3 -0
- package/dist/language/languageTypes.js.map +1 -0
- package/dist/language/languageUtils.d.ts +14 -0
- package/dist/language/languageUtils.js +73 -0
- package/dist/language/languageUtils.js.map +1 -0
- package/dist/language/languagesOf.d.ts +12 -0
- package/dist/language/languagesOf.js +16 -0
- package/dist/language/languagesOf.js.map +1 -0
- package/dist/setLanguagePreferences.d.ts +3 -0
- package/dist/setLanguagePreferences.js +9 -0
- package/dist/setLanguagePreferences.js.map +1 -0
- package/dist/subjectProxy/SubjectProxy.d.ts +14 -0
- package/dist/subjectProxy/SubjectProxy.js +3 -0
- package/dist/subjectProxy/SubjectProxy.js.map +1 -0
- package/dist/subjectProxy/createSubjectHandler.d.ts +6 -0
- package/dist/subjectProxy/createSubjectHandler.js +73 -0
- package/dist/subjectProxy/createSubjectHandler.js.map +1 -0
- package/dist/subjectProxy/deleteFromDataset.d.ts +3 -0
- package/dist/subjectProxy/deleteFromDataset.js +44 -0
- package/dist/subjectProxy/deleteFromDataset.js.map +1 -0
- package/dist/subjectProxy/getValueForKey.d.ts +5 -0
- package/dist/subjectProxy/getValueForKey.js +43 -0
- package/dist/subjectProxy/getValueForKey.js.map +1 -0
- package/dist/subjectProxy/isSubjectProxy.d.ts +4 -0
- package/dist/subjectProxy/isSubjectProxy.js +25 -0
- package/dist/subjectProxy/isSubjectProxy.js.map +1 -0
- package/dist/types.d.ts +9 -0
- package/dist/types.js +12 -0
- package/dist/types.js.map +1 -0
- package/dist/util/NodeSet.d.ts +11 -0
- package/dist/util/NodeSet.js +45 -0
- package/dist/util/NodeSet.js.map +1 -0
- package/dist/util/RawObject.d.ts +8 -0
- package/dist/util/RawObject.js +3 -0
- package/dist/util/RawObject.js.map +1 -0
- package/dist/util/addObjectToDataset.d.ts +8 -0
- package/dist/util/addObjectToDataset.js +83 -0
- package/dist/util/addObjectToDataset.js.map +1 -0
- package/dist/util/createInteractOptions.d.ts +6 -0
- package/dist/util/createInteractOptions.js +37 -0
- package/dist/util/createInteractOptions.js.map +1 -0
- package/dist/util/getNodeFromRaw.d.ts +6 -0
- package/dist/util/getNodeFromRaw.js +41 -0
- package/dist/util/getNodeFromRaw.js.map +1 -0
- package/dist/util/isProxy.d.ts +5 -0
- package/dist/util/isProxy.js +17 -0
- package/dist/util/isProxy.js.map +1 -0
- package/dist/util/nodeToJsonldRepresentation.d.ts +6 -0
- package/dist/util/nodeToJsonldRepresentation.js +74 -0
- package/dist/util/nodeToJsonldRepresentation.js.map +1 -0
- package/dist/write.d.ts +3 -0
- package/dist/write.js +9 -0
- package/dist/write.js.map +1 -0
- package/package.json +53 -0
- package/src/ContextUtil.ts +90 -0
- package/src/JsonldDatasetProxyBuilder.ts +106 -0
- package/src/ProxyContext.ts +110 -0
- package/src/arrayProxy/ArrayProxy.ts +20 -0
- package/src/arrayProxy/arrayMethods.ts +219 -0
- package/src/arrayProxy/createArrayHandler.ts +177 -0
- package/src/arrayProxy/isArrayProxy.ts +23 -0
- package/src/arrayProxy/modifyArray.ts +129 -0
- package/src/graphOf.ts +63 -0
- package/src/index.ts +37 -0
- package/src/jsonldDatasetProxy.ts +27 -0
- package/src/language/languageMapProxy.ts +75 -0
- package/src/language/languageSet.ts +129 -0
- package/src/language/languageTypes.ts +3 -0
- package/src/language/languageUtils.ts +159 -0
- package/src/language/languagesOf.ts +61 -0
- package/src/setLanguagePreferences.ts +14 -0
- package/src/subjectProxy/SubjectProxy.ts +20 -0
- package/src/subjectProxy/createSubjectHandler.ts +106 -0
- package/src/subjectProxy/deleteFromDataset.ts +44 -0
- package/src/subjectProxy/getValueForKey.ts +62 -0
- package/src/subjectProxy/isSubjectProxy.ts +30 -0
- package/src/types.ts +11 -0
- package/src/util/NodeSet.ts +47 -0
- package/src/util/RawObject.ts +13 -0
- package/src/util/addObjectToDataset.ts +141 -0
- package/src/util/createInteractOptions.ts +55 -0
- package/src/util/getNodeFromRaw.ts +45 -0
- package/src/util/isProxy.ts +20 -0
- package/src/util/nodeToJsonldRepresentation.ts +76 -0
- package/src/write.ts +12 -0
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
import type { PredicateNode, SubjectNode } from "@ldo/rdf-utils";
|
|
2
|
+
import { literal, quad } from "@rdfjs/data-model";
|
|
3
|
+
import type { ProxyContext } from "../ProxyContext";
|
|
4
|
+
import {
|
|
5
|
+
languageKeyToLiteralLanguage,
|
|
6
|
+
quadsToLanguageQuadMap,
|
|
7
|
+
languageDeleteMatch,
|
|
8
|
+
} from "./languageUtils";
|
|
9
|
+
import type { LanguageMap, LanguageSetMap } from "./languagesOf";
|
|
10
|
+
import LanguageSet from "./languageSet";
|
|
11
|
+
|
|
12
|
+
export function createLanguageMapProxy<
|
|
13
|
+
Target extends LanguageMap | LanguageSetMap,
|
|
14
|
+
>(
|
|
15
|
+
subject: SubjectNode,
|
|
16
|
+
predicate: PredicateNode,
|
|
17
|
+
proxyContext: ProxyContext,
|
|
18
|
+
isArray: boolean,
|
|
19
|
+
): Target {
|
|
20
|
+
const target: Target = {} as Target;
|
|
21
|
+
// Function to call to update the target to represent what's in the dataset
|
|
22
|
+
const targetSetter = (target: Target) => {
|
|
23
|
+
// Clear the target
|
|
24
|
+
Object.keys(target).forEach((key) => delete target[key]);
|
|
25
|
+
// Add current language map to target
|
|
26
|
+
const allQuads = proxyContext.dataset.match(subject, predicate);
|
|
27
|
+
const languageQuadMap = quadsToLanguageQuadMap(allQuads);
|
|
28
|
+
Object.entries(languageQuadMap).forEach(([language, quads]) => {
|
|
29
|
+
const stringArray = quads.toArray().map((quad) => quad.object.value);
|
|
30
|
+
if (isArray) {
|
|
31
|
+
target[language] = new Set(stringArray);
|
|
32
|
+
} else {
|
|
33
|
+
target[language] = stringArray[0];
|
|
34
|
+
}
|
|
35
|
+
});
|
|
36
|
+
};
|
|
37
|
+
|
|
38
|
+
targetSetter(target);
|
|
39
|
+
|
|
40
|
+
return new Proxy<Target>(target, {
|
|
41
|
+
get: (target, key) => {
|
|
42
|
+
targetSetter(target);
|
|
43
|
+
if (typeof key !== "string") {
|
|
44
|
+
return Reflect.get(target, key);
|
|
45
|
+
}
|
|
46
|
+
if (isArray) {
|
|
47
|
+
return new LanguageSet(subject, predicate, key, proxyContext);
|
|
48
|
+
}
|
|
49
|
+
return Reflect.get(target, key);
|
|
50
|
+
},
|
|
51
|
+
set: (target, key, value) => {
|
|
52
|
+
const language = languageKeyToLiteralLanguage(key);
|
|
53
|
+
// Delete all quads with the language currently
|
|
54
|
+
if (!isArray) {
|
|
55
|
+
languageDeleteMatch(proxyContext.dataset, subject, predicate, language);
|
|
56
|
+
}
|
|
57
|
+
// Add the new quad for the language
|
|
58
|
+
proxyContext.writeGraphs.forEach((writeGraph) => {
|
|
59
|
+
proxyContext.dataset.add(
|
|
60
|
+
quad(subject, predicate, literal(value, language), writeGraph),
|
|
61
|
+
);
|
|
62
|
+
});
|
|
63
|
+
return Reflect.set(target, key, value);
|
|
64
|
+
},
|
|
65
|
+
deleteProperty: (target, key) => {
|
|
66
|
+
languageDeleteMatch(
|
|
67
|
+
proxyContext.dataset,
|
|
68
|
+
subject,
|
|
69
|
+
predicate,
|
|
70
|
+
languageKeyToLiteralLanguage(key),
|
|
71
|
+
);
|
|
72
|
+
return Reflect.deleteProperty(target, key);
|
|
73
|
+
},
|
|
74
|
+
}) as Target;
|
|
75
|
+
}
|
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
import { literal, quad } from "@rdfjs/data-model";
|
|
2
|
+
import type { PredicateNode, SubjectNode } from "@ldo/rdf-utils";
|
|
3
|
+
import type { Dataset, Literal } from "@rdfjs/types";
|
|
4
|
+
import type { LanguageKey } from "./languageTypes";
|
|
5
|
+
import type { LiteralObjectQuad } from "./languageUtils";
|
|
6
|
+
import { languageDeleteMatch, languageMatch } from "./languageUtils";
|
|
7
|
+
import type { ProxyContext } from "../ProxyContext";
|
|
8
|
+
|
|
9
|
+
export default class LanguageSet implements Set<string> {
|
|
10
|
+
private subject: SubjectNode;
|
|
11
|
+
private predicate: PredicateNode;
|
|
12
|
+
private languageKey: LanguageKey;
|
|
13
|
+
private proxyContext: ProxyContext;
|
|
14
|
+
|
|
15
|
+
constructor(
|
|
16
|
+
subject: SubjectNode,
|
|
17
|
+
predicate: PredicateNode,
|
|
18
|
+
languageKey: LanguageKey,
|
|
19
|
+
proxyContext: ProxyContext,
|
|
20
|
+
) {
|
|
21
|
+
this.subject = subject;
|
|
22
|
+
this.predicate = predicate;
|
|
23
|
+
this.languageKey = languageKey;
|
|
24
|
+
this.proxyContext = proxyContext;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
private matchThis(): Dataset<LiteralObjectQuad> {
|
|
28
|
+
return languageMatch(
|
|
29
|
+
this.proxyContext.dataset,
|
|
30
|
+
this.subject,
|
|
31
|
+
this.predicate,
|
|
32
|
+
this.languageKey,
|
|
33
|
+
);
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
private getLiteral(value: string): Literal {
|
|
37
|
+
return this.languageKey === "@none"
|
|
38
|
+
? literal(value)
|
|
39
|
+
: literal(value, this.languageKey);
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
public get size(): number {
|
|
43
|
+
return this.matchThis().size;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
add(value: string): this {
|
|
47
|
+
this.proxyContext.writeGraphs.forEach((graph) => {
|
|
48
|
+
this.proxyContext.dataset.add(
|
|
49
|
+
quad(
|
|
50
|
+
this.subject,
|
|
51
|
+
this.predicate,
|
|
52
|
+
literal(value, this.languageKey),
|
|
53
|
+
graph,
|
|
54
|
+
),
|
|
55
|
+
);
|
|
56
|
+
});
|
|
57
|
+
return this;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
clear(): void {
|
|
61
|
+
languageDeleteMatch(
|
|
62
|
+
this.proxyContext.dataset,
|
|
63
|
+
this.subject,
|
|
64
|
+
this.predicate,
|
|
65
|
+
this.languageKey,
|
|
66
|
+
);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
delete(value: string): boolean {
|
|
70
|
+
const hadValue = this.has(value);
|
|
71
|
+
this.proxyContext.dataset.deleteMatches(
|
|
72
|
+
this.subject,
|
|
73
|
+
this.predicate,
|
|
74
|
+
this.getLiteral(value),
|
|
75
|
+
);
|
|
76
|
+
return hadValue;
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
forEach(
|
|
80
|
+
callbackfn: (value: string, value2: string, set: Set<string>) => void,
|
|
81
|
+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
82
|
+
thisArg?: any,
|
|
83
|
+
): void {
|
|
84
|
+
const quads = this.matchThis();
|
|
85
|
+
quads.forEach((curQuad) => {
|
|
86
|
+
callbackfn(curQuad.object.value, curQuad.object.value, thisArg || this);
|
|
87
|
+
});
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
has(item: string): boolean {
|
|
91
|
+
return (
|
|
92
|
+
this.proxyContext.dataset.match(
|
|
93
|
+
this.subject,
|
|
94
|
+
this.predicate,
|
|
95
|
+
this.getLiteral(item),
|
|
96
|
+
).size > 0
|
|
97
|
+
);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
*entries(): IterableIterator<[string, string]> {
|
|
101
|
+
const quads = this.matchThis();
|
|
102
|
+
for (const curQuad of quads) {
|
|
103
|
+
yield [curQuad.object.value, curQuad.object.value];
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
*keys(): IterableIterator<string> {
|
|
108
|
+
const quads = this.matchThis();
|
|
109
|
+
for (const curQuad of quads) {
|
|
110
|
+
yield curQuad.object.value;
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
*values(): IterableIterator<string> {
|
|
115
|
+
const quads = this.matchThis();
|
|
116
|
+
for (const curQuad of quads) {
|
|
117
|
+
yield curQuad.object.value;
|
|
118
|
+
}
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
*[Symbol.iterator](): IterableIterator<string> {
|
|
122
|
+
const quads = this.matchThis();
|
|
123
|
+
for (const curQuad of quads) {
|
|
124
|
+
yield curQuad.object.value;
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
[Symbol.toStringTag] = "LanguageSet";
|
|
129
|
+
}
|
|
@@ -0,0 +1,159 @@
|
|
|
1
|
+
import type { Dataset, Literal, Quad, Quad_Object } from "@rdfjs/types";
|
|
2
|
+
import type { ObjectNode, PredicateNode, SubjectNode } from "@ldo/rdf-utils";
|
|
3
|
+
import { createDataset } from "@ldo/dataset";
|
|
4
|
+
import type { LanguageKey, LanguageOrdering } from "./languageTypes";
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
*
|
|
8
|
+
* @param dataset
|
|
9
|
+
* @param subject
|
|
10
|
+
* @param predicate
|
|
11
|
+
* @param languageKey
|
|
12
|
+
* @returns
|
|
13
|
+
*/
|
|
14
|
+
export function languageMatch(
|
|
15
|
+
dataset: Dataset,
|
|
16
|
+
subject: ObjectNode,
|
|
17
|
+
predicate: PredicateNode,
|
|
18
|
+
languageKey: LanguageKey,
|
|
19
|
+
): Dataset<LiteralObjectQuad> {
|
|
20
|
+
const literalLanguage = languageKeyToLiteralLanguage(languageKey);
|
|
21
|
+
return dataset.match(subject, predicate).filter((quad) => {
|
|
22
|
+
return (
|
|
23
|
+
isLanguageLiteral(quad.object) && quad.object.language === literalLanguage
|
|
24
|
+
);
|
|
25
|
+
}) as Dataset<LiteralObjectQuad>;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
/**
|
|
29
|
+
*
|
|
30
|
+
* @param dataset
|
|
31
|
+
* @param subject
|
|
32
|
+
* @param predicate
|
|
33
|
+
* @param languageKey
|
|
34
|
+
*/
|
|
35
|
+
export function languageDeleteMatch(
|
|
36
|
+
dataset: Dataset,
|
|
37
|
+
subject: SubjectNode,
|
|
38
|
+
predicate: PredicateNode,
|
|
39
|
+
languageKey: LanguageKey,
|
|
40
|
+
): void {
|
|
41
|
+
const quadsToDelete = languageMatch(dataset, subject, predicate, languageKey);
|
|
42
|
+
quadsToDelete.forEach((quad) => {
|
|
43
|
+
dataset.delete(quad);
|
|
44
|
+
});
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/**
|
|
48
|
+
* Given a node, will return true if that node is a literal that could have a
|
|
49
|
+
* language. This does not guarantee that it is a language literal.
|
|
50
|
+
* @param node the node to test
|
|
51
|
+
* @returns boolean
|
|
52
|
+
*/
|
|
53
|
+
export function isLanguageLiteral(node: Quad_Object): node is Literal {
|
|
54
|
+
return (
|
|
55
|
+
node.termType === "Literal" &&
|
|
56
|
+
(node.datatype.value ===
|
|
57
|
+
"http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" ||
|
|
58
|
+
node.datatype.value === "http://www.w3.org/2001/XMLSchema#string")
|
|
59
|
+
);
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
export interface LiteralObjectQuad extends Quad {
|
|
63
|
+
object: Literal;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
export function quadsToLanguageQuadMap(
|
|
67
|
+
quads: Dataset,
|
|
68
|
+
): Record<LanguageKey, Dataset<LiteralObjectQuad>> {
|
|
69
|
+
const languageQuadMap: Record<LanguageKey, Dataset<LiteralObjectQuad>> = {};
|
|
70
|
+
quads.forEach((quad) => {
|
|
71
|
+
const literal = quad.object;
|
|
72
|
+
if (isLanguageLiteral(literal)) {
|
|
73
|
+
const languageKey = literalLanguageToLanguageKey(literal.language);
|
|
74
|
+
if (!languageQuadMap[languageKey]) {
|
|
75
|
+
languageQuadMap[languageKey] =
|
|
76
|
+
createDataset() as Dataset<LiteralObjectQuad>;
|
|
77
|
+
}
|
|
78
|
+
languageQuadMap[languageKey].add(quad as LiteralObjectQuad);
|
|
79
|
+
}
|
|
80
|
+
});
|
|
81
|
+
return languageQuadMap;
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
export function filterQuadsByLanguageOrdering(
|
|
85
|
+
quads: Dataset,
|
|
86
|
+
languageOrdering: LanguageOrdering,
|
|
87
|
+
): Dataset {
|
|
88
|
+
const languageQuadMap = quadsToLanguageQuadMap(quads);
|
|
89
|
+
const validLanguages = new Set(languageOrdering);
|
|
90
|
+
const presentLanguages = new Set(Object.keys(languageQuadMap));
|
|
91
|
+
for (const currentLanguageKey of languageOrdering) {
|
|
92
|
+
if (presentLanguages.has(currentLanguageKey)) {
|
|
93
|
+
return languageQuadMap[currentLanguageKey];
|
|
94
|
+
}
|
|
95
|
+
if (currentLanguageKey === "@other") {
|
|
96
|
+
for (const presentLang of presentLanguages) {
|
|
97
|
+
if (!validLanguages.has(presentLang)) {
|
|
98
|
+
return languageQuadMap[presentLang];
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
return createDataset();
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
export function getLanguageKeyForWriteOperation(
|
|
107
|
+
languageOrdering: LanguageOrdering,
|
|
108
|
+
): LanguageKey | undefined {
|
|
109
|
+
return languageOrdering.find((lang) => lang !== "@other");
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
// function addToDatasetMap(
|
|
113
|
+
// key: string,
|
|
114
|
+
// value: Quad,
|
|
115
|
+
// map: Record<string, Dataset>
|
|
116
|
+
// ) {
|
|
117
|
+
// if (!map[key]) {
|
|
118
|
+
// map[key] = createDataset();
|
|
119
|
+
// }
|
|
120
|
+
// map[key].add(value);
|
|
121
|
+
// }
|
|
122
|
+
|
|
123
|
+
// export function filterDatasetByLanguageOrdering(
|
|
124
|
+
// dataset: Dataset,
|
|
125
|
+
// proxyContext: ProxyContext
|
|
126
|
+
// ): Dataset {
|
|
127
|
+
// // TODO: This is an O(n) task that could be reduced to O(1) if we cached some
|
|
128
|
+
// // of the processing
|
|
129
|
+
// const validLangs = new Set(proxyContext.languageOrdering);
|
|
130
|
+
// const sortedLangs: Record<string, Dataset> = {};
|
|
131
|
+
// dataset.forEach((quad) => {
|
|
132
|
+
// const literal = quad.object;
|
|
133
|
+
// if (isLangStringNode(literal)) {
|
|
134
|
+
// if (literal.language === "") {
|
|
135
|
+
// addToDatasetMap("@none", quad, sortedLangs);
|
|
136
|
+
// } else if (validLangs.has(literal.language)) {
|
|
137
|
+
// addToDatasetMap(literal.language, quad, sortedLangs);
|
|
138
|
+
// } else {
|
|
139
|
+
// addToDatasetMap("@other", quad, sortedLangs);
|
|
140
|
+
// }
|
|
141
|
+
// }
|
|
142
|
+
// });
|
|
143
|
+
// for (const language of proxyContext.languageOrdering) {
|
|
144
|
+
// if (sortedLangs[language]) {
|
|
145
|
+
// return sortedLangs[language];
|
|
146
|
+
// }
|
|
147
|
+
// }
|
|
148
|
+
// return createDataset();
|
|
149
|
+
// }
|
|
150
|
+
|
|
151
|
+
export function languageKeyToLiteralLanguage(
|
|
152
|
+
languageKey: string | symbol,
|
|
153
|
+
): string {
|
|
154
|
+
return (languageKey === "@none" ? "" : languageKey) as string;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
export function literalLanguageToLanguageKey(literalLanguage: string): string {
|
|
158
|
+
return literalLanguage === "" ? "@none" : literalLanguage;
|
|
159
|
+
}
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
import { namedNode } from "@rdfjs/data-model";
|
|
2
|
+
import { getSubjectProxyFromObject } from "../subjectProxy/isSubjectProxy";
|
|
3
|
+
import type { ObjectLike } from "../types";
|
|
4
|
+
import { _getUnderlyingNode, _proxyContext } from "../types";
|
|
5
|
+
import { createLanguageMapProxy } from "./languageMapProxy";
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* -----------------------------------------------------------------------------
|
|
9
|
+
* Types
|
|
10
|
+
* -----------------------------------------------------------------------------
|
|
11
|
+
*/
|
|
12
|
+
|
|
13
|
+
export type LanguageMap = {
|
|
14
|
+
"@none"?: string;
|
|
15
|
+
[language: string]: string | undefined;
|
|
16
|
+
};
|
|
17
|
+
|
|
18
|
+
export type LanguageSetMap = {
|
|
19
|
+
"@none"?: LanguageSet;
|
|
20
|
+
[language: string]: LanguageSet | undefined;
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
export type LanguageSet = Set<string>;
|
|
24
|
+
|
|
25
|
+
export type LanguageOfConditionalReturn<
|
|
26
|
+
SubjectObject extends ObjectLike,
|
|
27
|
+
Key extends keyof SubjectObject,
|
|
28
|
+
> = NonNullable<SubjectObject[Key]> extends Array<unknown>
|
|
29
|
+
? LanguageSetMap
|
|
30
|
+
: LanguageMap;
|
|
31
|
+
|
|
32
|
+
/**
|
|
33
|
+
* -----------------------------------------------------------------------------
|
|
34
|
+
* Functions
|
|
35
|
+
* -----------------------------------------------------------------------------
|
|
36
|
+
*/
|
|
37
|
+
|
|
38
|
+
/**
|
|
39
|
+
*
|
|
40
|
+
* @param subject
|
|
41
|
+
* @param predicate
|
|
42
|
+
* @returns
|
|
43
|
+
*/
|
|
44
|
+
export function languagesOf<
|
|
45
|
+
SubjectObject extends ObjectLike,
|
|
46
|
+
Key extends keyof SubjectObject,
|
|
47
|
+
>(
|
|
48
|
+
subjectObject: SubjectObject,
|
|
49
|
+
key: Key,
|
|
50
|
+
): LanguageOfConditionalReturn<SubjectObject, Key> {
|
|
51
|
+
const proxy = getSubjectProxyFromObject(subjectObject);
|
|
52
|
+
const proxyContext = proxy[_proxyContext];
|
|
53
|
+
const subject = proxy[_getUnderlyingNode];
|
|
54
|
+
const predicate = namedNode(proxyContext.contextUtil.keyToIri(key as string));
|
|
55
|
+
return createLanguageMapProxy<LanguageMap>(
|
|
56
|
+
subject,
|
|
57
|
+
predicate,
|
|
58
|
+
proxyContext,
|
|
59
|
+
proxyContext.contextUtil.isArray(key as string),
|
|
60
|
+
) as LanguageOfConditionalReturn<SubjectObject, Key>;
|
|
61
|
+
}
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
import type { LanguageOrdering } from "./language/languageTypes";
|
|
2
|
+
import type { InteractOptions } from "./util/createInteractOptions";
|
|
3
|
+
import { createInteractOptions } from "./util/createInteractOptions";
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* Set the default language pr
|
|
7
|
+
* @param graphs The graphs that should be written to
|
|
8
|
+
* @returns a write builder
|
|
9
|
+
*/
|
|
10
|
+
export function setLanguagePreferences(
|
|
11
|
+
...languageOrdering: LanguageOrdering
|
|
12
|
+
): InteractOptions {
|
|
13
|
+
return createInteractOptions("languageOrdering", languageOrdering);
|
|
14
|
+
}
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
import type { GraphNode } from "@ldo/rdf-utils";
|
|
2
|
+
import type { BlankNode, Dataset, NamedNode } from "@rdfjs/types";
|
|
3
|
+
import type { ContextDefinition } from "jsonld";
|
|
4
|
+
import type { ProxyContext } from "../ProxyContext";
|
|
5
|
+
import type {
|
|
6
|
+
_getUnderlyingDataset,
|
|
7
|
+
_getUnderlyingNode,
|
|
8
|
+
_proxyContext,
|
|
9
|
+
_writeGraphs,
|
|
10
|
+
} from "../types";
|
|
11
|
+
|
|
12
|
+
export type SubjectProxy = {
|
|
13
|
+
"@id"?: string;
|
|
14
|
+
"@context": ContextDefinition;
|
|
15
|
+
readonly [key: string | number | symbol]: unknown;
|
|
16
|
+
readonly [_getUnderlyingDataset]: Dataset;
|
|
17
|
+
readonly [_getUnderlyingNode]: NamedNode | BlankNode;
|
|
18
|
+
[_proxyContext]: ProxyContext;
|
|
19
|
+
readonly [_writeGraphs]: GraphNode[];
|
|
20
|
+
};
|
|
@@ -0,0 +1,106 @@
|
|
|
1
|
+
import { namedNode, quad } from "@rdfjs/data-model";
|
|
2
|
+
import type { BlankNode, NamedNode } from "@rdfjs/types";
|
|
3
|
+
import { addObjectToDataset } from "../util/addObjectToDataset";
|
|
4
|
+
import { deleteValueFromDataset } from "./deleteFromDataset";
|
|
5
|
+
import {
|
|
6
|
+
_getUnderlyingDataset,
|
|
7
|
+
_getUnderlyingNode,
|
|
8
|
+
_proxyContext,
|
|
9
|
+
_writeGraphs,
|
|
10
|
+
} from "../types";
|
|
11
|
+
import { getValueForKey } from "./getValueForKey";
|
|
12
|
+
import type { ProxyContext } from "../ProxyContext";
|
|
13
|
+
|
|
14
|
+
export interface SubjectProxyTarget {
|
|
15
|
+
"@id": NamedNode | BlankNode;
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
export function createSubjectHandler(
|
|
19
|
+
initialProxyContext: ProxyContext,
|
|
20
|
+
): ProxyHandler<SubjectProxyTarget> {
|
|
21
|
+
let proxyContext = initialProxyContext;
|
|
22
|
+
return {
|
|
23
|
+
get(target: SubjectProxyTarget, key: string | symbol) {
|
|
24
|
+
switch (key) {
|
|
25
|
+
case _getUnderlyingDataset:
|
|
26
|
+
return proxyContext.dataset;
|
|
27
|
+
case _getUnderlyingNode:
|
|
28
|
+
return target["@id"];
|
|
29
|
+
case _proxyContext:
|
|
30
|
+
return proxyContext;
|
|
31
|
+
case _writeGraphs:
|
|
32
|
+
return proxyContext.writeGraphs;
|
|
33
|
+
case "@context":
|
|
34
|
+
return proxyContext.contextUtil.context;
|
|
35
|
+
}
|
|
36
|
+
return getValueForKey(target, key, proxyContext);
|
|
37
|
+
},
|
|
38
|
+
getOwnPropertyDescriptor(target: SubjectProxyTarget, key: string) {
|
|
39
|
+
return {
|
|
40
|
+
value: getValueForKey(target, key, proxyContext),
|
|
41
|
+
writable: true,
|
|
42
|
+
enumerable: true,
|
|
43
|
+
configurable: true,
|
|
44
|
+
};
|
|
45
|
+
},
|
|
46
|
+
ownKeys(target) {
|
|
47
|
+
const subject = target["@id"];
|
|
48
|
+
const tripleDataset = proxyContext.dataset.match(subject);
|
|
49
|
+
const keys: Set<string> = new Set(["@id"]);
|
|
50
|
+
tripleDataset.toArray().forEach((quad) => {
|
|
51
|
+
keys.add(proxyContext.contextUtil.iriToKey(quad.predicate.value));
|
|
52
|
+
});
|
|
53
|
+
return Array.from(keys);
|
|
54
|
+
},
|
|
55
|
+
set: (target: SubjectProxyTarget, key, value) => {
|
|
56
|
+
if (key === _proxyContext) {
|
|
57
|
+
proxyContext = value;
|
|
58
|
+
return true;
|
|
59
|
+
}
|
|
60
|
+
if (key === "@id" && typeof value === "string") {
|
|
61
|
+
// Replace Subject Quads
|
|
62
|
+
const currentSubjectQuads = proxyContext.dataset
|
|
63
|
+
.match(target["@id"])
|
|
64
|
+
.toArray();
|
|
65
|
+
const newSubjectQuads = currentSubjectQuads.map((curQuad) =>
|
|
66
|
+
quad(
|
|
67
|
+
namedNode(value),
|
|
68
|
+
curQuad.predicate,
|
|
69
|
+
curQuad.object,
|
|
70
|
+
curQuad.graph,
|
|
71
|
+
),
|
|
72
|
+
);
|
|
73
|
+
currentSubjectQuads.forEach((curQuad) =>
|
|
74
|
+
proxyContext.dataset.delete(curQuad),
|
|
75
|
+
);
|
|
76
|
+
proxyContext.dataset.addAll(newSubjectQuads);
|
|
77
|
+
// Replace Object Quads
|
|
78
|
+
const currentObjectQuads = proxyContext.dataset
|
|
79
|
+
.match(undefined, undefined, target["@id"])
|
|
80
|
+
.toArray();
|
|
81
|
+
const newObjectQuads = currentObjectQuads.map((curQuad) =>
|
|
82
|
+
quad(
|
|
83
|
+
curQuad.subject,
|
|
84
|
+
curQuad.predicate,
|
|
85
|
+
namedNode(value),
|
|
86
|
+
curQuad.graph,
|
|
87
|
+
),
|
|
88
|
+
);
|
|
89
|
+
currentObjectQuads.forEach((curQuad) =>
|
|
90
|
+
proxyContext.dataset.delete(curQuad),
|
|
91
|
+
);
|
|
92
|
+
proxyContext.dataset.addAll(newObjectQuads);
|
|
93
|
+
target["@id"] = namedNode(value);
|
|
94
|
+
}
|
|
95
|
+
addObjectToDataset(
|
|
96
|
+
{ "@id": target["@id"], [key]: value },
|
|
97
|
+
true,
|
|
98
|
+
proxyContext,
|
|
99
|
+
);
|
|
100
|
+
return true;
|
|
101
|
+
},
|
|
102
|
+
deleteProperty(target, key) {
|
|
103
|
+
return deleteValueFromDataset(target, key, proxyContext);
|
|
104
|
+
},
|
|
105
|
+
};
|
|
106
|
+
}
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
import { namedNode, quad } from "@rdfjs/data-model";
|
|
2
|
+
import type { Term } from "@rdfjs/types";
|
|
3
|
+
import type { SubjectProxyTarget } from "./createSubjectHandler";
|
|
4
|
+
import type { ProxyContext } from "../ProxyContext";
|
|
5
|
+
|
|
6
|
+
export function deleteValueFromDataset(
|
|
7
|
+
target: SubjectProxyTarget,
|
|
8
|
+
key: string | symbol,
|
|
9
|
+
proxyContext: ProxyContext,
|
|
10
|
+
) {
|
|
11
|
+
const nodesToRemove: Term[] = [];
|
|
12
|
+
if (key === "@context") {
|
|
13
|
+
return true;
|
|
14
|
+
}
|
|
15
|
+
if (key === "toString" || key === Symbol.toStringTag) {
|
|
16
|
+
return true;
|
|
17
|
+
}
|
|
18
|
+
if (typeof key === "symbol") {
|
|
19
|
+
return true;
|
|
20
|
+
}
|
|
21
|
+
const subject = target["@id"];
|
|
22
|
+
const predicate = namedNode(proxyContext.contextUtil.keyToIri(key));
|
|
23
|
+
if (key === "@id") {
|
|
24
|
+
nodesToRemove.push(target["@id"]);
|
|
25
|
+
} else {
|
|
26
|
+
const objectDataset = proxyContext.dataset.match(subject, predicate);
|
|
27
|
+
if (objectDataset.size === 0) {
|
|
28
|
+
return true;
|
|
29
|
+
} else {
|
|
30
|
+
nodesToRemove.push(...objectDataset.toArray().map((quad) => quad.object));
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
nodesToRemove.forEach((term) => {
|
|
34
|
+
if (term.termType === "Literal") {
|
|
35
|
+
proxyContext.dataset.delete(quad(subject, predicate, term));
|
|
36
|
+
return true;
|
|
37
|
+
} else if (term.termType === "NamedNode") {
|
|
38
|
+
proxyContext.dataset.deleteMatches(term, undefined, undefined);
|
|
39
|
+
proxyContext.dataset.deleteMatches(undefined, undefined, term);
|
|
40
|
+
return true;
|
|
41
|
+
}
|
|
42
|
+
});
|
|
43
|
+
return true;
|
|
44
|
+
}
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
import type { SubjectProxyTarget } from "./createSubjectHandler";
|
|
2
|
+
import { namedNode } from "@rdfjs/data-model";
|
|
3
|
+
import { nodeToJsonldRepresentation } from "../util/nodeToJsonldRepresentation";
|
|
4
|
+
import type { SubjectProxy } from "./SubjectProxy";
|
|
5
|
+
import type { ArrayProxy } from "../arrayProxy/ArrayProxy";
|
|
6
|
+
import type { ProxyContext } from "../ProxyContext";
|
|
7
|
+
import { filterQuadsByLanguageOrdering } from "../language/languageUtils";
|
|
8
|
+
|
|
9
|
+
/**
|
|
10
|
+
* Given a subject target and a key return the correct value
|
|
11
|
+
*/
|
|
12
|
+
export function getValueForKey(
|
|
13
|
+
target: SubjectProxyTarget,
|
|
14
|
+
key: string | symbol,
|
|
15
|
+
proxyContext: ProxyContext,
|
|
16
|
+
): SubjectProxy | ArrayProxy | string | number | boolean | undefined {
|
|
17
|
+
const { contextUtil, dataset } = proxyContext;
|
|
18
|
+
if (key === "@id") {
|
|
19
|
+
if (target["@id"].termType === "BlankNode") {
|
|
20
|
+
return undefined;
|
|
21
|
+
}
|
|
22
|
+
return contextUtil.iriToKey(target["@id"].value);
|
|
23
|
+
}
|
|
24
|
+
if (key === "toString" || key === Symbol.toStringTag) {
|
|
25
|
+
// TODO: this toString method right now returns [object Object],
|
|
26
|
+
// which is correct, but it could be more descriptive, especially
|
|
27
|
+
// because console.log doesn't return anyting helpful due to the proxy.
|
|
28
|
+
return Reflect.get(target, "toString");
|
|
29
|
+
}
|
|
30
|
+
if (typeof key === "symbol") {
|
|
31
|
+
return;
|
|
32
|
+
}
|
|
33
|
+
const subject = target["@id"];
|
|
34
|
+
const predicate = namedNode(contextUtil.keyToIri(key));
|
|
35
|
+
if (contextUtil.isArray(key)) {
|
|
36
|
+
const arrayProxy = proxyContext.createArrayProxy(
|
|
37
|
+
[subject, predicate, null, null],
|
|
38
|
+
false,
|
|
39
|
+
undefined,
|
|
40
|
+
contextUtil.isLangString(key),
|
|
41
|
+
);
|
|
42
|
+
return arrayProxy;
|
|
43
|
+
}
|
|
44
|
+
let objectDataset = dataset.match(subject, predicate);
|
|
45
|
+
if (contextUtil.isLangString(key)) {
|
|
46
|
+
objectDataset = filterQuadsByLanguageOrdering(
|
|
47
|
+
objectDataset,
|
|
48
|
+
proxyContext.languageOrdering,
|
|
49
|
+
);
|
|
50
|
+
}
|
|
51
|
+
if (objectDataset.size === 0) {
|
|
52
|
+
return undefined;
|
|
53
|
+
} else if (objectDataset.size === 1) {
|
|
54
|
+
const thing = nodeToJsonldRepresentation(
|
|
55
|
+
objectDataset.toArray()[0].object,
|
|
56
|
+
proxyContext,
|
|
57
|
+
);
|
|
58
|
+
return thing;
|
|
59
|
+
} else {
|
|
60
|
+
return proxyContext.createArrayProxy([subject, predicate, null, null]);
|
|
61
|
+
}
|
|
62
|
+
}
|