@arrai-innovations/reactive-helpers 2.4.0 → 2.5.1
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/package.json +1 -1
- package/tests/unit/utils/flattenPaths.spec.js +118 -0
- package/use/listCalculated.js +6 -0
- package/use/listRelated.js +6 -0
- package/use/objectCalculated.js +5 -1
- package/utils/flattenPaths.js +28 -0
- package/utils/index.js +1 -0
package/package.json
CHANGED
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
import { flattenPaths } from "../../../utils/flattenPaths";
|
|
2
|
+
|
|
3
|
+
describe("utils/flattenPaths", () => {
|
|
4
|
+
describe("flattenPaths", () => {
|
|
5
|
+
describe("should work on objects as the base", () => {
|
|
6
|
+
it("with a single level", () => {
|
|
7
|
+
expect(flattenPaths({ a: 1, b: 2 })).toEqual(["a", "b"]);
|
|
8
|
+
});
|
|
9
|
+
it("with a single level and a nested object", () => {
|
|
10
|
+
expect(flattenPaths({ a: 1, b: { c: 2 } })).toEqual(["a", "b.c"]);
|
|
11
|
+
});
|
|
12
|
+
it("with a single level and a nested array", () => {
|
|
13
|
+
expect(flattenPaths({ a: 1, b: [2] })).toEqual(["a", "b[0]"]);
|
|
14
|
+
});
|
|
15
|
+
it("with a single level and a nested object and array", () => {
|
|
16
|
+
expect(flattenPaths({ a: 1, b: { c: [2] } })).toEqual(["a", "b.c[0]"]);
|
|
17
|
+
});
|
|
18
|
+
});
|
|
19
|
+
describe("should work on arrays as the base", () => {
|
|
20
|
+
it("with a single level", () => {
|
|
21
|
+
expect(flattenPaths([1, 2])).toEqual(["[0]", "[1]"]);
|
|
22
|
+
});
|
|
23
|
+
it("with a single level and a nested object", () => {
|
|
24
|
+
expect(flattenPaths([1, { c: 2 }])).toEqual(["[0]", "[1].c"]);
|
|
25
|
+
});
|
|
26
|
+
it("with a single level and a nested array", () => {
|
|
27
|
+
expect(flattenPaths([1, [2]])).toEqual(["[0]", "[1][0]"]);
|
|
28
|
+
});
|
|
29
|
+
it("with a single level and a nested object and array", () => {
|
|
30
|
+
expect(flattenPaths([1, { c: [2] }])).toEqual(["[0]", "[1].c[0]"]);
|
|
31
|
+
});
|
|
32
|
+
});
|
|
33
|
+
it("should work on a real world example", () => {
|
|
34
|
+
const toBeFlattened = {
|
|
35
|
+
id: 1,
|
|
36
|
+
name: "test",
|
|
37
|
+
description: "test",
|
|
38
|
+
type: "test",
|
|
39
|
+
status: {
|
|
40
|
+
id: 1,
|
|
41
|
+
code: "test",
|
|
42
|
+
name: "test",
|
|
43
|
+
},
|
|
44
|
+
products: [
|
|
45
|
+
{
|
|
46
|
+
id: 1,
|
|
47
|
+
name: "test",
|
|
48
|
+
description: "test",
|
|
49
|
+
categories: [
|
|
50
|
+
{
|
|
51
|
+
id: 1,
|
|
52
|
+
name: "test",
|
|
53
|
+
description: "test",
|
|
54
|
+
},
|
|
55
|
+
{
|
|
56
|
+
id: 2,
|
|
57
|
+
name: "test2",
|
|
58
|
+
description: "test2",
|
|
59
|
+
},
|
|
60
|
+
],
|
|
61
|
+
price: "$1.00",
|
|
62
|
+
regularPrice: "$1.00",
|
|
63
|
+
},
|
|
64
|
+
{
|
|
65
|
+
id: 2,
|
|
66
|
+
name: "test2",
|
|
67
|
+
description: "test2",
|
|
68
|
+
categories: [
|
|
69
|
+
{
|
|
70
|
+
id: 3,
|
|
71
|
+
name: "test3",
|
|
72
|
+
description: "test3",
|
|
73
|
+
},
|
|
74
|
+
{
|
|
75
|
+
id: 4,
|
|
76
|
+
name: "test4",
|
|
77
|
+
description: "test4",
|
|
78
|
+
},
|
|
79
|
+
],
|
|
80
|
+
price: "$2.00",
|
|
81
|
+
regularPrice: "$2.00",
|
|
82
|
+
},
|
|
83
|
+
],
|
|
84
|
+
};
|
|
85
|
+
expect(flattenPaths(toBeFlattened)).toEqual([
|
|
86
|
+
"id",
|
|
87
|
+
"name",
|
|
88
|
+
"description",
|
|
89
|
+
"type",
|
|
90
|
+
"status.id",
|
|
91
|
+
"status.code",
|
|
92
|
+
"status.name",
|
|
93
|
+
"products[0].id",
|
|
94
|
+
"products[0].name",
|
|
95
|
+
"products[0].description",
|
|
96
|
+
"products[0].categories[0].id",
|
|
97
|
+
"products[0].categories[0].name",
|
|
98
|
+
"products[0].categories[0].description",
|
|
99
|
+
"products[0].categories[1].id",
|
|
100
|
+
"products[0].categories[1].name",
|
|
101
|
+
"products[0].categories[1].description",
|
|
102
|
+
"products[0].price",
|
|
103
|
+
"products[0].regularPrice",
|
|
104
|
+
"products[1].id",
|
|
105
|
+
"products[1].name",
|
|
106
|
+
"products[1].description",
|
|
107
|
+
"products[1].categories[0].id",
|
|
108
|
+
"products[1].categories[0].name",
|
|
109
|
+
"products[1].categories[0].description",
|
|
110
|
+
"products[1].categories[1].id",
|
|
111
|
+
"products[1].categories[1].name",
|
|
112
|
+
"products[1].categories[1].description",
|
|
113
|
+
"products[1].price",
|
|
114
|
+
"products[1].regularPrice",
|
|
115
|
+
]);
|
|
116
|
+
});
|
|
117
|
+
});
|
|
118
|
+
});
|
package/use/listCalculated.js
CHANGED
|
@@ -101,6 +101,12 @@ export function useListCalculated({
|
|
|
101
101
|
const es = effectScope();
|
|
102
102
|
|
|
103
103
|
es.run(() => {
|
|
104
|
+
state.loading = toRef(parentState, "loading");
|
|
105
|
+
state.errored = toRef(parentState, "errored");
|
|
106
|
+
state.error = toRef(parentState, "error");
|
|
107
|
+
|
|
108
|
+
state.retrieveArgs = toRef(parentState, "retrieveArgs");
|
|
109
|
+
state.listArgs = toRef(parentState, "listArgs");
|
|
104
110
|
state.order = toRef(parentState, "order");
|
|
105
111
|
state.objectsInOrder = computed(() => state.order.map((id) => state.objects[id]));
|
|
106
112
|
|
package/use/listRelated.js
CHANGED
|
@@ -131,6 +131,12 @@ export function useListRelated({
|
|
|
131
131
|
const es = effectScope();
|
|
132
132
|
|
|
133
133
|
es.run(() => {
|
|
134
|
+
state.loading = toRef(parentState, "loading");
|
|
135
|
+
state.errored = toRef(parentState, "errored");
|
|
136
|
+
state.error = toRef(parentState, "error");
|
|
137
|
+
|
|
138
|
+
state.retrieveArgs = toRef(parentState, "retrieveArgs");
|
|
139
|
+
state.listArgs = toRef(parentState, "listArgs");
|
|
134
140
|
state.order = toRef(parentState, "order");
|
|
135
141
|
state.objectsInOrder = computed(() => state.order.map((id) => state.objects[id]));
|
|
136
142
|
|
package/use/objectCalculated.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { computed, effectScope, onScopeDispose, reactive, watch } from "vue";
|
|
1
|
+
import { computed, effectScope, onScopeDispose, reactive, toRef, watch } from "vue";
|
|
2
2
|
import { keyDiff } from "../utils";
|
|
3
3
|
|
|
4
4
|
export function useObjectCalculateds(instances, args) {
|
|
@@ -61,6 +61,10 @@ export function useObjectCalculated({
|
|
|
61
61
|
return false;
|
|
62
62
|
},
|
|
63
63
|
});
|
|
64
|
+
state.loading = toRef(parentState, "loading");
|
|
65
|
+
state.error = toRef(parentState, "error");
|
|
66
|
+
state.errored = toRef(parentState, "errored");
|
|
67
|
+
state.deleted = toRef(parentState, "deleted");
|
|
64
68
|
|
|
65
69
|
watch(
|
|
66
70
|
[() => Object.keys(state.calculatedObjectRules)],
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import { isArray, isObject } from "lodash";
|
|
2
|
+
|
|
3
|
+
export function flattenPaths(arrayOrObject, currentPath = "") {
|
|
4
|
+
// arrayOrObject keys or indexes values can be objects or arrays.
|
|
5
|
+
// find all paths you could use lodash to "get()" to.
|
|
6
|
+
// indexes use `[${index}]`, keys use `.${key}`
|
|
7
|
+
// first level should not include a leading ".", `[${index}]` or `${key}` is fine.
|
|
8
|
+
const paths = [];
|
|
9
|
+
const keysOrIndexes = isArray(arrayOrObject);
|
|
10
|
+
const dotOrNot = currentPath ? "." : "";
|
|
11
|
+
if (isObject(arrayOrObject)) {
|
|
12
|
+
Object.keys(arrayOrObject).forEach((key) => {
|
|
13
|
+
const value = arrayOrObject[key];
|
|
14
|
+
const keyPath = keysOrIndexes ? `[${key}]` : `${dotOrNot}${key}`;
|
|
15
|
+
if (isObject(value) || isArray(value)) {
|
|
16
|
+
paths.push(...flattenPaths(value, `${currentPath}${keyPath}`));
|
|
17
|
+
} else {
|
|
18
|
+
paths.push(`${currentPath}${keyPath}`);
|
|
19
|
+
}
|
|
20
|
+
});
|
|
21
|
+
} else {
|
|
22
|
+
// values
|
|
23
|
+
if (currentPath) {
|
|
24
|
+
paths.push(currentPath);
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
return paths;
|
|
28
|
+
}
|