@hyper-fetch/firebase 5.0.0
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/.eslintrc.json +6 -0
- package/.firebaserc +5 -0
- package/README.md +73 -0
- package/database.rules.json +11 -0
- package/dist/index.cjs.js +1204 -0
- package/dist/index.cjs.js.map +7 -0
- package/dist/index.d.ts +293 -0
- package/dist/index.esm.js +1270 -0
- package/dist/index.esm.js.map +7 -0
- package/firebase.json +28 -0
- package/firestore.indexes.json +4 -0
- package/firestore.rules +8 -0
- package/package.json +75 -0
- package/src/adapter/admin/adapter.admin.sockets.ts +14 -0
- package/src/adapter/admin/adapter.admin.ts +72 -0
- package/src/adapter/admin/adapter.admin.types.ts +15 -0
- package/src/adapter/admin/index.ts +3 -0
- package/src/adapter/browser/adapter.browser.sockets.ts +18 -0
- package/src/adapter/browser/adapter.browser.ts +81 -0
- package/src/adapter/browser/adapter.browser.types.ts +15 -0
- package/src/adapter/browser/index.ts +3 -0
- package/src/adapter/index.ts +3 -0
- package/src/adapter/types/adapter.firestore.types.ts +78 -0
- package/src/adapter/types/adapter.realtime.types.ts +82 -0
- package/src/adapter/types/firestore.admin.types.ts +17 -0
- package/src/adapter/types/index.ts +4 -0
- package/src/adapter/types/realtime.admin.types.ts +17 -0
- package/src/constraints/constraints.types.ts +71 -0
- package/src/constraints/firebase.constraints.ts +117 -0
- package/src/constraints/index.ts +2 -0
- package/src/firestore/admin/firestore.admin.methods.ts +86 -0
- package/src/firestore/admin/firestore.admin.sockets.ts +86 -0
- package/src/firestore/admin/firestore.admin.utils.ts +69 -0
- package/src/firestore/admin/index.ts +2 -0
- package/src/firestore/browser/firestore.browser.methods.ts +105 -0
- package/src/firestore/browser/firestore.browser.sockets.ts +102 -0
- package/src/firestore/browser/firestore.browser.utils.ts +39 -0
- package/src/firestore/browser/index.ts +3 -0
- package/src/firestore/index.ts +3 -0
- package/src/firestore/utils/firestore.utils.ts +17 -0
- package/src/firestore/utils/index.ts +1 -0
- package/src/index.ts +5 -0
- package/src/realtime/admin/index.ts +2 -0
- package/src/realtime/admin/realtime.admin.methods.ts +74 -0
- package/src/realtime/admin/realtime.admin.sockets.ts +93 -0
- package/src/realtime/admin/realtime.admin.utils.ts +54 -0
- package/src/realtime/browser/index.ts +3 -0
- package/src/realtime/browser/realtime.browser.methods.ts +78 -0
- package/src/realtime/browser/realtime.browser.sockets.ts +96 -0
- package/src/realtime/browser/realtime.browser.utils.ts +59 -0
- package/src/realtime/index.ts +3 -0
- package/src/realtime/utils/index.ts +1 -0
- package/src/realtime/utils/realtime.utils.ts +7 -0
- package/src/utils/cache.utils.ts +33 -0
- package/src/utils/index.ts +2 -0
- package/src/utils/misc.ts +10 -0
- package/test.sh +3 -0
- package/tsconfig.json +8 -0
|
@@ -0,0 +1,1270 @@
|
|
|
1
|
+
var __create = Object.create;
|
|
2
|
+
var __defProp = Object.defineProperty;
|
|
3
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
6
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
7
|
+
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
|
|
8
|
+
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
|
|
9
|
+
}) : x)(function(x) {
|
|
10
|
+
if (typeof require !== "undefined")
|
|
11
|
+
return require.apply(this, arguments);
|
|
12
|
+
throw new Error('Dynamic require of "' + x + '" is not supported');
|
|
13
|
+
});
|
|
14
|
+
var __commonJS = (cb, mod) => function __require2() {
|
|
15
|
+
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
16
|
+
};
|
|
17
|
+
var __export = (target, all) => {
|
|
18
|
+
for (var name in all)
|
|
19
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
20
|
+
};
|
|
21
|
+
var __copyProps = (to, from, except, desc) => {
|
|
22
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
23
|
+
for (let key of __getOwnPropNames(from))
|
|
24
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
25
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
26
|
+
}
|
|
27
|
+
return to;
|
|
28
|
+
};
|
|
29
|
+
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
|
|
30
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
31
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
32
|
+
mod
|
|
33
|
+
));
|
|
34
|
+
var __async = (__this, __arguments, generator) => {
|
|
35
|
+
return new Promise((resolve, reject) => {
|
|
36
|
+
var fulfilled = (value) => {
|
|
37
|
+
try {
|
|
38
|
+
step(generator.next(value));
|
|
39
|
+
} catch (e) {
|
|
40
|
+
reject(e);
|
|
41
|
+
}
|
|
42
|
+
};
|
|
43
|
+
var rejected = (value) => {
|
|
44
|
+
try {
|
|
45
|
+
step(generator.throw(value));
|
|
46
|
+
} catch (e) {
|
|
47
|
+
reject(e);
|
|
48
|
+
}
|
|
49
|
+
};
|
|
50
|
+
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
|
51
|
+
step((generator = generator.apply(__this, __arguments)).next());
|
|
52
|
+
});
|
|
53
|
+
};
|
|
54
|
+
|
|
55
|
+
// ../../node_modules/methods/index.js
|
|
56
|
+
var require_methods = __commonJS({
|
|
57
|
+
"../../node_modules/methods/index.js"(exports, module) {
|
|
58
|
+
"use strict";
|
|
59
|
+
var http = __require("http");
|
|
60
|
+
module.exports = getCurrentNodeMethods() || getBasicNodeMethods();
|
|
61
|
+
function getCurrentNodeMethods() {
|
|
62
|
+
return http.METHODS && http.METHODS.map(function lowerCaseMethod(method) {
|
|
63
|
+
return method.toLowerCase();
|
|
64
|
+
});
|
|
65
|
+
}
|
|
66
|
+
function getBasicNodeMethods() {
|
|
67
|
+
return [
|
|
68
|
+
"get",
|
|
69
|
+
"post",
|
|
70
|
+
"put",
|
|
71
|
+
"head",
|
|
72
|
+
"delete",
|
|
73
|
+
"options",
|
|
74
|
+
"trace",
|
|
75
|
+
"copy",
|
|
76
|
+
"lock",
|
|
77
|
+
"mkcol",
|
|
78
|
+
"move",
|
|
79
|
+
"purge",
|
|
80
|
+
"propfind",
|
|
81
|
+
"proppatch",
|
|
82
|
+
"unlock",
|
|
83
|
+
"report",
|
|
84
|
+
"mkactivity",
|
|
85
|
+
"checkout",
|
|
86
|
+
"merge",
|
|
87
|
+
"m-search",
|
|
88
|
+
"notify",
|
|
89
|
+
"subscribe",
|
|
90
|
+
"unsubscribe",
|
|
91
|
+
"patch",
|
|
92
|
+
"search",
|
|
93
|
+
"connect"
|
|
94
|
+
];
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
// src/index.ts
|
|
100
|
+
var src_exports = {};
|
|
101
|
+
__export(src_exports, {
|
|
102
|
+
$endAt: () => $endAt,
|
|
103
|
+
$endBefore: () => $endBefore,
|
|
104
|
+
$equalTo: () => $equalTo,
|
|
105
|
+
$limit: () => $limit,
|
|
106
|
+
$limitToFirst: () => $limitToFirst,
|
|
107
|
+
$limitToLast: () => $limitToLast,
|
|
108
|
+
$orderBy: () => $orderBy,
|
|
109
|
+
$orderByChild: () => $orderByChild,
|
|
110
|
+
$orderByKey: () => $orderByKey,
|
|
111
|
+
$orderByValue: () => $orderByValue,
|
|
112
|
+
$startAfter: () => $startAfter,
|
|
113
|
+
$startAt: () => $startAt,
|
|
114
|
+
$where: () => $where,
|
|
115
|
+
FirestoreMethods: () => FirestoreMethods,
|
|
116
|
+
FirestoreQueryConstraints: () => FirestoreQueryConstraints,
|
|
117
|
+
RealtimeDBMethods: () => RealtimeDBMethods,
|
|
118
|
+
RealtimeQueryConstraints: () => RealtimeQueryConstraints,
|
|
119
|
+
SharedQueryConstraints: () => SharedQueryConstraints,
|
|
120
|
+
applyFireStoreAdminConstraint: () => applyFireStoreAdminConstraint,
|
|
121
|
+
applyFireStoreAdminConstraints: () => applyFireStoreAdminConstraints,
|
|
122
|
+
applyRealtimeAdminConstraint: () => applyRealtimeAdminConstraint,
|
|
123
|
+
applyRealtimeAdminConstraints: () => applyRealtimeAdminConstraints,
|
|
124
|
+
firebaseAdapter: () => firebaseAdapter,
|
|
125
|
+
firebaseAdminAdapter: () => firebaseAdminAdapter,
|
|
126
|
+
firebaseSocketsAdapter: () => firebaseSocketsAdapter,
|
|
127
|
+
firebaseSocketsAdminAdapter: () => firebaseSocketsAdminAdapter,
|
|
128
|
+
firestoreSockets: () => firestoreSockets,
|
|
129
|
+
getFirestoreAdminMethods: () => getFirestoreAdminMethods,
|
|
130
|
+
getFirestoreBrowserMethods: () => getFirestoreBrowserMethods,
|
|
131
|
+
getGroupedResultFirestore: () => getGroupedResultFirestore,
|
|
132
|
+
getOrderedResultFirestore: () => getOrderedResultFirestore,
|
|
133
|
+
getOrderedResultRealtime: () => getOrderedResultRealtime,
|
|
134
|
+
getRealtimeDbAdminMethods: () => getRealtimeDbAdminMethods,
|
|
135
|
+
getRealtimeDbBrowserMethods: () => getRealtimeDbBrowserMethods,
|
|
136
|
+
getRef: () => getRef,
|
|
137
|
+
mapConstraint: () => mapConstraint,
|
|
138
|
+
mapRealtimeConstraint: () => mapRealtimeConstraint,
|
|
139
|
+
realtimeSockets: () => realtimeSockets
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
// src/adapter/types/adapter.firestore.types.ts
|
|
143
|
+
var FirestoreMethods = /* @__PURE__ */ ((FirestoreMethods2) => {
|
|
144
|
+
FirestoreMethods2["addDoc"] = "addDoc";
|
|
145
|
+
FirestoreMethods2["getDoc"] = "getDoc";
|
|
146
|
+
FirestoreMethods2["getDocs"] = "getDocs";
|
|
147
|
+
FirestoreMethods2["setDoc"] = "setDoc";
|
|
148
|
+
FirestoreMethods2["updateDoc"] = "updateDoc";
|
|
149
|
+
FirestoreMethods2["deleteDoc"] = "deleteDoc";
|
|
150
|
+
return FirestoreMethods2;
|
|
151
|
+
})(FirestoreMethods || {});
|
|
152
|
+
|
|
153
|
+
// src/adapter/types/adapter.realtime.types.ts
|
|
154
|
+
var RealtimeDBMethods = /* @__PURE__ */ ((RealtimeDBMethods2) => {
|
|
155
|
+
RealtimeDBMethods2["set"] = "set";
|
|
156
|
+
RealtimeDBMethods2["push"] = "push";
|
|
157
|
+
RealtimeDBMethods2["update"] = "update";
|
|
158
|
+
RealtimeDBMethods2["get"] = "get";
|
|
159
|
+
RealtimeDBMethods2["remove"] = "remove";
|
|
160
|
+
return RealtimeDBMethods2;
|
|
161
|
+
})(RealtimeDBMethods || {});
|
|
162
|
+
|
|
163
|
+
// src/adapter/admin/adapter.admin.ts
|
|
164
|
+
import { getAdapterBindings } from "@hyper-fetch/core";
|
|
165
|
+
import { Firestore as Firestore3 } from "firebase-admin/firestore";
|
|
166
|
+
|
|
167
|
+
// src/firestore/browser/firestore.browser.methods.ts
|
|
168
|
+
import {
|
|
169
|
+
addDoc,
|
|
170
|
+
collection,
|
|
171
|
+
deleteDoc,
|
|
172
|
+
doc,
|
|
173
|
+
getDoc,
|
|
174
|
+
getDocs,
|
|
175
|
+
query,
|
|
176
|
+
setDoc,
|
|
177
|
+
updateDoc
|
|
178
|
+
} from "firebase/firestore";
|
|
179
|
+
|
|
180
|
+
// src/utils/misc.ts
|
|
181
|
+
var getStatus = (res) => {
|
|
182
|
+
return Array.isArray(res) && res.length === 0 || res == null ? "emptyResource" : "success";
|
|
183
|
+
};
|
|
184
|
+
var isDocOrQuery = (fullUrl) => {
|
|
185
|
+
const withoutSurroundingSlashes = fullUrl.replace(/^\/|\/$/g, "");
|
|
186
|
+
const pathElements = withoutSurroundingSlashes.split("/").length;
|
|
187
|
+
return pathElements % 2 === 0 ? "doc" : "query";
|
|
188
|
+
};
|
|
189
|
+
|
|
190
|
+
// src/firestore/utils/firestore.utils.ts
|
|
191
|
+
var getOrderedResultFirestore = (snapshot) => {
|
|
192
|
+
const result = [];
|
|
193
|
+
snapshot.docs.forEach((d) => {
|
|
194
|
+
result.push(d.data());
|
|
195
|
+
});
|
|
196
|
+
return result.length > 0 ? result : null;
|
|
197
|
+
};
|
|
198
|
+
var getGroupedResultFirestore = (snapshot) => {
|
|
199
|
+
const groupedResult = { added: [], modified: [], removed: [] };
|
|
200
|
+
snapshot.docChanges().forEach((change) => {
|
|
201
|
+
groupedResult[change.type].push(change.doc.data());
|
|
202
|
+
});
|
|
203
|
+
return [...groupedResult.added, ...groupedResult.modified, ...groupedResult.removed].length > 0 ? groupedResult : null;
|
|
204
|
+
};
|
|
205
|
+
|
|
206
|
+
// src/firestore/browser/firestore.browser.utils.ts
|
|
207
|
+
import { endAt, endBefore, limit, orderBy, startAfter, startAt, where } from "firebase/firestore";
|
|
208
|
+
|
|
209
|
+
// src/constraints/firebase.constraints.ts
|
|
210
|
+
var SharedQueryConstraints = /* @__PURE__ */ ((SharedQueryConstraints2) => {
|
|
211
|
+
SharedQueryConstraints2["START_AT"] = "startAt";
|
|
212
|
+
SharedQueryConstraints2["START_AFTER"] = "startAfter";
|
|
213
|
+
SharedQueryConstraints2["END_AT"] = "endAt";
|
|
214
|
+
SharedQueryConstraints2["END_BEFORE"] = "endBefore";
|
|
215
|
+
return SharedQueryConstraints2;
|
|
216
|
+
})(SharedQueryConstraints || {});
|
|
217
|
+
var RealtimeQueryConstraints = /* @__PURE__ */ ((RealtimeQueryConstraints2) => {
|
|
218
|
+
RealtimeQueryConstraints2["ORDER_BY_CHILD"] = "orderByChild";
|
|
219
|
+
RealtimeQueryConstraints2["ORDER_BY_KEY"] = "orderByKey";
|
|
220
|
+
RealtimeQueryConstraints2["ORDER_BY_VALUE"] = "orderByValue";
|
|
221
|
+
RealtimeQueryConstraints2["LIMIT_TO_FIRST"] = "limitToFirst";
|
|
222
|
+
RealtimeQueryConstraints2["LIMIT_TO_LAST"] = "limitToLast";
|
|
223
|
+
RealtimeQueryConstraints2["EQUAL_TO"] = "equalTo";
|
|
224
|
+
return RealtimeQueryConstraints2;
|
|
225
|
+
})(RealtimeQueryConstraints || {});
|
|
226
|
+
var FirestoreQueryConstraints = /* @__PURE__ */ ((FirestoreQueryConstraints2) => {
|
|
227
|
+
FirestoreQueryConstraints2["WHERE"] = "where";
|
|
228
|
+
FirestoreQueryConstraints2["ORDER_BY"] = "orderBy";
|
|
229
|
+
FirestoreQueryConstraints2["LIMIT"] = "limit";
|
|
230
|
+
return FirestoreQueryConstraints2;
|
|
231
|
+
})(FirestoreQueryConstraints || {});
|
|
232
|
+
var $where = (fieldPath, opStr, value) => {
|
|
233
|
+
return {
|
|
234
|
+
toString: () => `${"where" /* WHERE */}_${fieldPath}${opStr}${value}`,
|
|
235
|
+
type: "where" /* WHERE */,
|
|
236
|
+
values: [fieldPath, opStr, value]
|
|
237
|
+
};
|
|
238
|
+
};
|
|
239
|
+
var $orderBy = (fieldPath, directionStr) => {
|
|
240
|
+
return {
|
|
241
|
+
toString: () => `${"orderBy" /* ORDER_BY */}_${fieldPath}_${directionStr || ""}`,
|
|
242
|
+
type: "orderBy" /* ORDER_BY */,
|
|
243
|
+
values: [fieldPath, directionStr]
|
|
244
|
+
};
|
|
245
|
+
};
|
|
246
|
+
var $limit = (num) => {
|
|
247
|
+
return {
|
|
248
|
+
toString: () => `${"limit" /* LIMIT */}_${num}`,
|
|
249
|
+
type: "limit" /* LIMIT */,
|
|
250
|
+
values: [num]
|
|
251
|
+
};
|
|
252
|
+
};
|
|
253
|
+
var startEndConstraintsImpl = (constraintType) => {
|
|
254
|
+
return (...docOrFields) => {
|
|
255
|
+
if (docOrFields.length === 1 && docOrFields[0].query) {
|
|
256
|
+
return {
|
|
257
|
+
toString: () => {
|
|
258
|
+
var _a, _b, _c;
|
|
259
|
+
return `${constraintType}_${(_c = (_b = (_a = docOrFields[0].query) == null ? void 0 : _a._query) == null ? void 0 : _b.memoizedTarget) == null ? void 0 : _c.memoizedCanonicalId}`;
|
|
260
|
+
},
|
|
261
|
+
type: constraintType,
|
|
262
|
+
values: [docOrFields]
|
|
263
|
+
};
|
|
264
|
+
}
|
|
265
|
+
return {
|
|
266
|
+
toString: () => `${constraintType}_${docOrFields}`,
|
|
267
|
+
type: constraintType,
|
|
268
|
+
values: [docOrFields]
|
|
269
|
+
};
|
|
270
|
+
};
|
|
271
|
+
};
|
|
272
|
+
var $startAt = startEndConstraintsImpl("startAt" /* START_AT */);
|
|
273
|
+
var $startAfter = startEndConstraintsImpl("startAfter" /* START_AFTER */);
|
|
274
|
+
var $endAt = startEndConstraintsImpl("endAt" /* END_AT */);
|
|
275
|
+
var $endBefore = startEndConstraintsImpl("endBefore" /* END_BEFORE */);
|
|
276
|
+
var $orderByChild = (path) => {
|
|
277
|
+
return {
|
|
278
|
+
toString: () => `${"orderByChild" /* ORDER_BY_CHILD */}_${path}`,
|
|
279
|
+
type: "orderByChild" /* ORDER_BY_CHILD */,
|
|
280
|
+
values: [path]
|
|
281
|
+
};
|
|
282
|
+
};
|
|
283
|
+
var $orderByKey = () => {
|
|
284
|
+
return {
|
|
285
|
+
toString: () => `${"orderByKey" /* ORDER_BY_KEY */}`,
|
|
286
|
+
type: "orderByKey" /* ORDER_BY_KEY */,
|
|
287
|
+
values: []
|
|
288
|
+
};
|
|
289
|
+
};
|
|
290
|
+
var $orderByValue = () => {
|
|
291
|
+
return {
|
|
292
|
+
toString: () => `${"orderByValue" /* ORDER_BY_VALUE */}`,
|
|
293
|
+
type: "orderByValue" /* ORDER_BY_VALUE */,
|
|
294
|
+
values: []
|
|
295
|
+
};
|
|
296
|
+
};
|
|
297
|
+
var $limitToFirst = (num) => {
|
|
298
|
+
return {
|
|
299
|
+
toString: () => `${"limitToFirst" /* LIMIT_TO_FIRST */}_${num}`,
|
|
300
|
+
type: "limitToFirst" /* LIMIT_TO_FIRST */,
|
|
301
|
+
values: [num]
|
|
302
|
+
};
|
|
303
|
+
};
|
|
304
|
+
var $limitToLast = (num) => {
|
|
305
|
+
return {
|
|
306
|
+
toString: () => `${"limitToLast" /* LIMIT_TO_LAST */}_${num}`,
|
|
307
|
+
type: "limitToLast" /* LIMIT_TO_LAST */,
|
|
308
|
+
values: [num]
|
|
309
|
+
};
|
|
310
|
+
};
|
|
311
|
+
var $equalTo = (value) => {
|
|
312
|
+
return {
|
|
313
|
+
toString: () => `${"limitToLast" /* LIMIT_TO_LAST */}_${value}`,
|
|
314
|
+
type: "equalTo" /* EQUAL_TO */,
|
|
315
|
+
values: [value]
|
|
316
|
+
};
|
|
317
|
+
};
|
|
318
|
+
|
|
319
|
+
// src/firestore/browser/firestore.browser.utils.ts
|
|
320
|
+
var mapConstraint = ({ type, values }) => {
|
|
321
|
+
switch (type) {
|
|
322
|
+
case "where" /* WHERE */: {
|
|
323
|
+
const [fieldPath, strOp, value] = values;
|
|
324
|
+
return where(fieldPath, strOp, value);
|
|
325
|
+
}
|
|
326
|
+
case "orderBy" /* ORDER_BY */: {
|
|
327
|
+
const [field, ord] = values;
|
|
328
|
+
return orderBy(field, ord);
|
|
329
|
+
}
|
|
330
|
+
case "limit" /* LIMIT */: {
|
|
331
|
+
const [limitValue] = values;
|
|
332
|
+
return limit(limitValue);
|
|
333
|
+
}
|
|
334
|
+
case "startAt" /* START_AT */: {
|
|
335
|
+
const [docOrFields] = values;
|
|
336
|
+
return startAt(docOrFields);
|
|
337
|
+
}
|
|
338
|
+
case "startAfter" /* START_AFTER */: {
|
|
339
|
+
const [docOrFields] = values;
|
|
340
|
+
return startAfter(docOrFields);
|
|
341
|
+
}
|
|
342
|
+
case "endAt" /* END_AT */: {
|
|
343
|
+
const [docOrFields] = values;
|
|
344
|
+
return endAt(docOrFields);
|
|
345
|
+
}
|
|
346
|
+
case "endBefore" /* END_BEFORE */: {
|
|
347
|
+
const [docOrFields] = values;
|
|
348
|
+
return endBefore(docOrFields);
|
|
349
|
+
}
|
|
350
|
+
default:
|
|
351
|
+
throw new Error(`Unknown method ${type}`);
|
|
352
|
+
}
|
|
353
|
+
};
|
|
354
|
+
|
|
355
|
+
// src/firestore/browser/firestore.browser.methods.ts
|
|
356
|
+
var getFirestoreBrowserMethods = (request, database, url, onSuccess, onError, resolve, events) => {
|
|
357
|
+
const [cleanUrl] = url.split("?");
|
|
358
|
+
const methods = {
|
|
359
|
+
getDoc: () => __async(void 0, null, function* () {
|
|
360
|
+
const path = doc(database, cleanUrl);
|
|
361
|
+
const snapshot = yield getDoc(path);
|
|
362
|
+
const result = snapshot.data() || null;
|
|
363
|
+
const status = result ? "success" : "emptyResource";
|
|
364
|
+
return { result, status, extra: { ref: path, snapshot } };
|
|
365
|
+
}),
|
|
366
|
+
getDocs: (_0) => __async(void 0, [_0], function* ({
|
|
367
|
+
constraints = []
|
|
368
|
+
}) {
|
|
369
|
+
const queryConstraints = constraints.map((constr) => mapConstraint(constr));
|
|
370
|
+
const path = collection(database, cleanUrl);
|
|
371
|
+
const q = query(path, ...queryConstraints);
|
|
372
|
+
const querySnapshot = yield getDocs(q);
|
|
373
|
+
const result = getOrderedResultFirestore(querySnapshot);
|
|
374
|
+
const status = getStatus(result);
|
|
375
|
+
return { result, status, extra: { ref: path, snapshot: querySnapshot } };
|
|
376
|
+
}),
|
|
377
|
+
setDoc: (_0) => __async(void 0, [_0], function* ({ data, options }) {
|
|
378
|
+
const path = doc(database, cleanUrl);
|
|
379
|
+
const merge = (options == null ? void 0 : options.merge) === true;
|
|
380
|
+
yield setDoc(path, data, { merge });
|
|
381
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
382
|
+
}),
|
|
383
|
+
addDoc: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
384
|
+
const path = collection(database, cleanUrl);
|
|
385
|
+
const docRef = yield addDoc(path, data);
|
|
386
|
+
return { result: data, status: "success", extra: { ref: docRef } };
|
|
387
|
+
}),
|
|
388
|
+
updateDoc: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
389
|
+
const path = doc(database, cleanUrl);
|
|
390
|
+
yield updateDoc(path, data);
|
|
391
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
392
|
+
}),
|
|
393
|
+
deleteDoc: () => __async(void 0, null, function* () {
|
|
394
|
+
const path = doc(database, cleanUrl);
|
|
395
|
+
yield deleteDoc(path);
|
|
396
|
+
return { result: null, status: "success", extra: { ref: path } };
|
|
397
|
+
})
|
|
398
|
+
};
|
|
399
|
+
return (methodName, data) => __async(void 0, null, function* () {
|
|
400
|
+
try {
|
|
401
|
+
events.onRequestStart();
|
|
402
|
+
const { result, status, extra } = yield methods[methodName](data);
|
|
403
|
+
events.onRequestEnd();
|
|
404
|
+
events.onResponseStart();
|
|
405
|
+
onSuccess(result, status, extra, resolve);
|
|
406
|
+
events.onResponseEnd();
|
|
407
|
+
} catch (e) {
|
|
408
|
+
events.onRequestEnd();
|
|
409
|
+
events.onResponseStart();
|
|
410
|
+
onError(e, "error", {}, resolve);
|
|
411
|
+
events.onResponseEnd();
|
|
412
|
+
}
|
|
413
|
+
});
|
|
414
|
+
};
|
|
415
|
+
|
|
416
|
+
// src/firestore/browser/firestore.browser.sockets.ts
|
|
417
|
+
import { getSocketAdapterBindings } from "@hyper-fetch/sockets";
|
|
418
|
+
import { onSnapshot, doc as doc2, query as query2, collection as collection2, disableNetwork, enableNetwork } from "firebase/firestore";
|
|
419
|
+
var firestoreSockets = (database) => {
|
|
420
|
+
return (socket) => {
|
|
421
|
+
const {
|
|
422
|
+
open,
|
|
423
|
+
connecting,
|
|
424
|
+
reconnectionAttempts,
|
|
425
|
+
listeners,
|
|
426
|
+
removeListener,
|
|
427
|
+
onConnect,
|
|
428
|
+
onReconnect,
|
|
429
|
+
onDisconnect,
|
|
430
|
+
onListen,
|
|
431
|
+
onOpen,
|
|
432
|
+
onClose,
|
|
433
|
+
onEvent,
|
|
434
|
+
onError
|
|
435
|
+
} = getSocketAdapterBindings(socket, { open: true });
|
|
436
|
+
const connect = () => {
|
|
437
|
+
const enabled = onConnect();
|
|
438
|
+
if (enabled) {
|
|
439
|
+
enableNetwork(database);
|
|
440
|
+
onOpen();
|
|
441
|
+
}
|
|
442
|
+
};
|
|
443
|
+
const disconnect = () => {
|
|
444
|
+
disableNetwork(database);
|
|
445
|
+
onDisconnect();
|
|
446
|
+
onClose();
|
|
447
|
+
};
|
|
448
|
+
const reconnect = () => {
|
|
449
|
+
onReconnect(disconnect, connect);
|
|
450
|
+
};
|
|
451
|
+
const listen = (listener, callback) => {
|
|
452
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
453
|
+
const { options } = listener;
|
|
454
|
+
let path;
|
|
455
|
+
const queryType = isDocOrQuery(fullUrl);
|
|
456
|
+
if (queryType === "doc") {
|
|
457
|
+
path = doc2(database, fullUrl);
|
|
458
|
+
} else {
|
|
459
|
+
const constraints = (options == null ? void 0 : options.constraints) || [];
|
|
460
|
+
const queryConstraints = constraints.map((constr) => mapConstraint(constr)) || [];
|
|
461
|
+
path = query2(collection2(database, fullUrl), ...queryConstraints);
|
|
462
|
+
}
|
|
463
|
+
let unsubscribe = () => {
|
|
464
|
+
};
|
|
465
|
+
let unmount = () => {
|
|
466
|
+
};
|
|
467
|
+
let clearListeners = () => {
|
|
468
|
+
};
|
|
469
|
+
unsubscribe = onSnapshot(
|
|
470
|
+
path,
|
|
471
|
+
(snapshot) => {
|
|
472
|
+
const response = queryType === "doc" ? snapshot.data() || null : getOrderedResultFirestore(snapshot);
|
|
473
|
+
const status = getStatus(response);
|
|
474
|
+
const groupedResult = (options == null ? void 0 : options.groupByChangeType) === true ? getGroupedResultFirestore(snapshot) : null;
|
|
475
|
+
const extra = { ref: path, snapshot, groupedResult, status };
|
|
476
|
+
callback({ data: response, extra });
|
|
477
|
+
onEvent(listener.endpoint, response, extra);
|
|
478
|
+
},
|
|
479
|
+
(error) => {
|
|
480
|
+
onError(error);
|
|
481
|
+
}
|
|
482
|
+
);
|
|
483
|
+
unmount = onListen(listener, callback, unsubscribe);
|
|
484
|
+
clearListeners = () => {
|
|
485
|
+
unsubscribe();
|
|
486
|
+
unmount();
|
|
487
|
+
};
|
|
488
|
+
return clearListeners;
|
|
489
|
+
};
|
|
490
|
+
const emit = () => __async(void 0, null, function* () {
|
|
491
|
+
throw new Error("Cannot emit from Firestore database socket.");
|
|
492
|
+
});
|
|
493
|
+
return {
|
|
494
|
+
open,
|
|
495
|
+
reconnectionAttempts,
|
|
496
|
+
listeners,
|
|
497
|
+
connecting,
|
|
498
|
+
listen,
|
|
499
|
+
removeListener,
|
|
500
|
+
emit,
|
|
501
|
+
connect,
|
|
502
|
+
reconnect,
|
|
503
|
+
disconnect
|
|
504
|
+
};
|
|
505
|
+
};
|
|
506
|
+
};
|
|
507
|
+
|
|
508
|
+
// src/firestore/admin/firestore.admin.methods.ts
|
|
509
|
+
var getFirestoreAdminMethods = (request, database, url, onSuccess, onError, resolve, events) => {
|
|
510
|
+
const [cleanUrl] = url.split("?");
|
|
511
|
+
const methods = {
|
|
512
|
+
getDoc: () => __async(void 0, null, function* () {
|
|
513
|
+
const path = getRef(database, cleanUrl);
|
|
514
|
+
const snapshot = yield path.get();
|
|
515
|
+
const result = snapshot.data() || null;
|
|
516
|
+
const status = result ? "success" : "emptyResource";
|
|
517
|
+
return { result, status, extra: { ref: path, snapshot } };
|
|
518
|
+
}),
|
|
519
|
+
getDocs: (_0) => __async(void 0, [_0], function* ({ constraints = [] }) {
|
|
520
|
+
const path = getRef(database, cleanUrl);
|
|
521
|
+
const query5 = applyFireStoreAdminConstraints(path, constraints);
|
|
522
|
+
const querySnapshot = yield query5.get();
|
|
523
|
+
const result = getOrderedResultFirestore(querySnapshot);
|
|
524
|
+
const status = getStatus(result);
|
|
525
|
+
return { result, status, extra: { ref: path, snapshot: querySnapshot } };
|
|
526
|
+
}),
|
|
527
|
+
setDoc: (_0) => __async(void 0, [_0], function* ({ data, options }) {
|
|
528
|
+
const path = getRef(database, cleanUrl);
|
|
529
|
+
const merge = (options == null ? void 0 : options.merge) === true;
|
|
530
|
+
const res = yield path.set(data, { merge });
|
|
531
|
+
return { result: res, status: "success", extra: { ref: path } };
|
|
532
|
+
}),
|
|
533
|
+
addDoc: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
534
|
+
const ref3 = getRef(database, cleanUrl);
|
|
535
|
+
const docRef = yield ref3.add(data);
|
|
536
|
+
return { result: data, status: "success", extra: { ref: docRef } };
|
|
537
|
+
}),
|
|
538
|
+
updateDoc: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
539
|
+
const path = getRef(database, cleanUrl);
|
|
540
|
+
yield path.update(data);
|
|
541
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
542
|
+
}),
|
|
543
|
+
deleteDoc: () => __async(void 0, null, function* () {
|
|
544
|
+
const path = getRef(database, cleanUrl);
|
|
545
|
+
yield path.delete();
|
|
546
|
+
return { result: null, status: "success", extra: { ref: path } };
|
|
547
|
+
})
|
|
548
|
+
};
|
|
549
|
+
return (methodName, data) => __async(void 0, null, function* () {
|
|
550
|
+
try {
|
|
551
|
+
events.onRequestStart();
|
|
552
|
+
const { result, status, extra } = yield methods[methodName](data);
|
|
553
|
+
events.onRequestEnd();
|
|
554
|
+
events.onResponseStart();
|
|
555
|
+
onSuccess(result, status, extra, resolve);
|
|
556
|
+
events.onResponseEnd();
|
|
557
|
+
} catch (e) {
|
|
558
|
+
events.onRequestEnd();
|
|
559
|
+
events.onResponseStart();
|
|
560
|
+
onError(e, "error", {}, resolve);
|
|
561
|
+
events.onResponseEnd();
|
|
562
|
+
}
|
|
563
|
+
});
|
|
564
|
+
};
|
|
565
|
+
|
|
566
|
+
// src/firestore/admin/firestore.admin.utils.ts
|
|
567
|
+
var getRef = (db, fullUrl) => {
|
|
568
|
+
const withoutSurroundingSlashes = fullUrl.replace(/^\/|\/$/g, "");
|
|
569
|
+
const urlParts = withoutSurroundingSlashes.split("/").map((element, index) => {
|
|
570
|
+
return index % 2 === 0 ? ["collection", element] : ["doc", element];
|
|
571
|
+
});
|
|
572
|
+
return urlParts.reduce((_db, value) => {
|
|
573
|
+
const [method, pathPart] = value;
|
|
574
|
+
if (method === "doc" && "doc" in _db) {
|
|
575
|
+
return _db.doc(pathPart);
|
|
576
|
+
}
|
|
577
|
+
if (method === "collection" && "collection" in _db) {
|
|
578
|
+
return _db.collection(pathPart);
|
|
579
|
+
}
|
|
580
|
+
return _db;
|
|
581
|
+
}, db);
|
|
582
|
+
};
|
|
583
|
+
var applyFireStoreAdminConstraint = (collectionRef, { type, values }) => {
|
|
584
|
+
switch (type) {
|
|
585
|
+
case "where" /* WHERE */: {
|
|
586
|
+
const [fieldPath, strOp, value] = values;
|
|
587
|
+
return collectionRef.where(fieldPath, strOp, value);
|
|
588
|
+
}
|
|
589
|
+
case "orderBy" /* ORDER_BY */: {
|
|
590
|
+
const [field, ord] = values;
|
|
591
|
+
return collectionRef.orderBy(field, ord);
|
|
592
|
+
}
|
|
593
|
+
case "limit" /* LIMIT */: {
|
|
594
|
+
const [limitValue] = values;
|
|
595
|
+
return collectionRef.limit(limitValue);
|
|
596
|
+
}
|
|
597
|
+
case "startAt" /* START_AT */: {
|
|
598
|
+
const [docOrFields] = values;
|
|
599
|
+
return collectionRef.startAt(docOrFields);
|
|
600
|
+
}
|
|
601
|
+
case "startAfter" /* START_AFTER */: {
|
|
602
|
+
const [docOrFields] = values;
|
|
603
|
+
return collectionRef.startAfter(docOrFields);
|
|
604
|
+
}
|
|
605
|
+
case "endAt" /* END_AT */: {
|
|
606
|
+
const [docOrFields] = values;
|
|
607
|
+
return collectionRef.endAt(docOrFields);
|
|
608
|
+
}
|
|
609
|
+
case "endBefore" /* END_BEFORE */: {
|
|
610
|
+
const [docOrFields] = values;
|
|
611
|
+
return collectionRef.endBefore(docOrFields);
|
|
612
|
+
}
|
|
613
|
+
default:
|
|
614
|
+
throw new Error(`Unknown method ${type}`);
|
|
615
|
+
}
|
|
616
|
+
};
|
|
617
|
+
var applyFireStoreAdminConstraints = (collectionRef, constraints) => {
|
|
618
|
+
return constraints.reduce((collection3, constraint) => {
|
|
619
|
+
return applyFireStoreAdminConstraint(collection3, constraint);
|
|
620
|
+
}, collectionRef);
|
|
621
|
+
};
|
|
622
|
+
|
|
623
|
+
// src/realtime/admin/realtime.admin.methods.ts
|
|
624
|
+
var getRealtimeDbAdminMethods = (request, database, url, onSuccess, onError, resolve, events) => {
|
|
625
|
+
const [fullUrl] = url.split("?");
|
|
626
|
+
const path = database.ref(fullUrl);
|
|
627
|
+
const methods = {
|
|
628
|
+
get: (_0) => __async(void 0, [_0], function* ({ constraints }) {
|
|
629
|
+
const docOrQuery = isDocOrQuery(fullUrl);
|
|
630
|
+
const q = applyRealtimeAdminConstraints(path, constraints);
|
|
631
|
+
const snapshot = yield q.get();
|
|
632
|
+
const res = docOrQuery === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
633
|
+
const status = getStatus(res);
|
|
634
|
+
return { result: res, status, extra: { ref: path, snapshot } };
|
|
635
|
+
}),
|
|
636
|
+
set: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
637
|
+
yield path.set(data);
|
|
638
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
639
|
+
}),
|
|
640
|
+
push: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
641
|
+
const resRef = yield path.push(data);
|
|
642
|
+
return { result: data, status: "success", extra: { ref: resRef, key: resRef.key } };
|
|
643
|
+
}),
|
|
644
|
+
update: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
645
|
+
yield path.update(data);
|
|
646
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
647
|
+
}),
|
|
648
|
+
remove: () => __async(void 0, null, function* () {
|
|
649
|
+
yield path.remove();
|
|
650
|
+
return { result: null, status: "success", extra: { ref: path } };
|
|
651
|
+
})
|
|
652
|
+
};
|
|
653
|
+
return (methodName, data) => __async(void 0, null, function* () {
|
|
654
|
+
try {
|
|
655
|
+
events.onRequestStart();
|
|
656
|
+
const { result, status, extra } = yield methods[methodName](data);
|
|
657
|
+
events.onRequestEnd();
|
|
658
|
+
events.onResponseStart();
|
|
659
|
+
onSuccess(result, status, extra, resolve);
|
|
660
|
+
events.onResponseEnd();
|
|
661
|
+
} catch (e) {
|
|
662
|
+
events.onRequestEnd();
|
|
663
|
+
events.onResponseStart();
|
|
664
|
+
onError(e, "error", {}, resolve);
|
|
665
|
+
events.onResponseEnd();
|
|
666
|
+
}
|
|
667
|
+
});
|
|
668
|
+
};
|
|
669
|
+
|
|
670
|
+
// src/realtime/admin/realtime.admin.utils.ts
|
|
671
|
+
var applyRealtimeAdminConstraint = (ref3, { type, values }) => {
|
|
672
|
+
switch (type) {
|
|
673
|
+
case "orderByChild" /* ORDER_BY_CHILD */: {
|
|
674
|
+
const [value] = values;
|
|
675
|
+
return ref3.orderByChild(value);
|
|
676
|
+
}
|
|
677
|
+
case "orderByKey" /* ORDER_BY_KEY */: {
|
|
678
|
+
return ref3.orderByKey();
|
|
679
|
+
}
|
|
680
|
+
case "orderByValue" /* ORDER_BY_VALUE */: {
|
|
681
|
+
return ref3.orderByValue();
|
|
682
|
+
}
|
|
683
|
+
case "startAt" /* START_AT */: {
|
|
684
|
+
const [[value]] = values;
|
|
685
|
+
return ref3.startAt(value);
|
|
686
|
+
}
|
|
687
|
+
case "startAfter" /* START_AFTER */: {
|
|
688
|
+
const [[value]] = values;
|
|
689
|
+
return ref3.startAfter(value);
|
|
690
|
+
}
|
|
691
|
+
case "endAt" /* END_AT */: {
|
|
692
|
+
const [[value]] = values;
|
|
693
|
+
return ref3.endAt(value);
|
|
694
|
+
}
|
|
695
|
+
case "endBefore" /* END_BEFORE */: {
|
|
696
|
+
const [[value]] = values;
|
|
697
|
+
return ref3.endBefore(value);
|
|
698
|
+
}
|
|
699
|
+
case "limitToFirst" /* LIMIT_TO_FIRST */: {
|
|
700
|
+
const [value] = values;
|
|
701
|
+
return ref3.limitToFirst(value);
|
|
702
|
+
}
|
|
703
|
+
case "limitToLast" /* LIMIT_TO_LAST */: {
|
|
704
|
+
const [value] = values;
|
|
705
|
+
return ref3.limitToLast(value);
|
|
706
|
+
}
|
|
707
|
+
case "equalTo" /* EQUAL_TO */: {
|
|
708
|
+
const [value] = values;
|
|
709
|
+
return ref3.equalTo(value);
|
|
710
|
+
}
|
|
711
|
+
default:
|
|
712
|
+
throw new Error(`Unknown method ${type}`);
|
|
713
|
+
}
|
|
714
|
+
};
|
|
715
|
+
var applyRealtimeAdminConstraints = (ref3, constraints) => {
|
|
716
|
+
return constraints.reduce((collection3, constraint) => {
|
|
717
|
+
return applyRealtimeAdminConstraint(collection3, constraint);
|
|
718
|
+
}, ref3);
|
|
719
|
+
};
|
|
720
|
+
|
|
721
|
+
// src/realtime/browser/realtime.browser.methods.ts
|
|
722
|
+
import { get, push, query as query3, ref, remove, set, update } from "firebase/database";
|
|
723
|
+
var getRealtimeDbBrowserMethods = (request, database, url, onSuccess, onError, resolve, events) => {
|
|
724
|
+
const [fullUrl] = url.split("?");
|
|
725
|
+
const path = ref(database, fullUrl);
|
|
726
|
+
const methods = {
|
|
727
|
+
get: (_0) => __async(void 0, [_0], function* ({
|
|
728
|
+
constraints = []
|
|
729
|
+
}) {
|
|
730
|
+
const params = constraints.map((constraint) => mapRealtimeConstraint(constraint));
|
|
731
|
+
const q = query3(path, ...params);
|
|
732
|
+
const snapshot = yield get(q);
|
|
733
|
+
const res = isDocOrQuery(fullUrl) === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
734
|
+
const status = getStatus(res);
|
|
735
|
+
return { result: res, status, extra: { ref: path, snapshot } };
|
|
736
|
+
}),
|
|
737
|
+
set: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
738
|
+
yield set(path, data);
|
|
739
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
740
|
+
}),
|
|
741
|
+
push: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
742
|
+
const resRef = yield push(path, data);
|
|
743
|
+
return { result: data, status: "success", extra: { ref: resRef, key: resRef.key } };
|
|
744
|
+
}),
|
|
745
|
+
update: (_0) => __async(void 0, [_0], function* ({ data }) {
|
|
746
|
+
yield update(path, data);
|
|
747
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
748
|
+
}),
|
|
749
|
+
remove: () => __async(void 0, null, function* () {
|
|
750
|
+
yield remove(path);
|
|
751
|
+
return { result: null, status: "success", extra: { ref: path } };
|
|
752
|
+
})
|
|
753
|
+
};
|
|
754
|
+
return (methodName, data) => __async(void 0, null, function* () {
|
|
755
|
+
try {
|
|
756
|
+
events.onRequestStart();
|
|
757
|
+
const { result, status, extra } = yield methods[methodName](data);
|
|
758
|
+
events.onRequestEnd();
|
|
759
|
+
events.onResponseStart();
|
|
760
|
+
onSuccess(result, status, extra, resolve);
|
|
761
|
+
events.onResponseEnd();
|
|
762
|
+
} catch (e) {
|
|
763
|
+
events.onRequestEnd();
|
|
764
|
+
events.onResponseStart();
|
|
765
|
+
onError(e, "error", {}, resolve);
|
|
766
|
+
events.onResponseEnd();
|
|
767
|
+
}
|
|
768
|
+
});
|
|
769
|
+
};
|
|
770
|
+
|
|
771
|
+
// src/realtime/browser/realtime.browser.utils.ts
|
|
772
|
+
import {
|
|
773
|
+
endAt as endAt2,
|
|
774
|
+
endBefore as endBefore2,
|
|
775
|
+
equalTo,
|
|
776
|
+
limitToFirst,
|
|
777
|
+
limitToLast,
|
|
778
|
+
orderByChild,
|
|
779
|
+
orderByKey,
|
|
780
|
+
orderByValue,
|
|
781
|
+
startAfter as startAfter2,
|
|
782
|
+
startAt as startAt2
|
|
783
|
+
} from "firebase/database";
|
|
784
|
+
var mapRealtimeConstraint = ({ type, values }) => {
|
|
785
|
+
switch (type) {
|
|
786
|
+
case "orderByChild" /* ORDER_BY_CHILD */: {
|
|
787
|
+
const [value] = values;
|
|
788
|
+
return orderByChild(value);
|
|
789
|
+
}
|
|
790
|
+
case "orderByKey" /* ORDER_BY_KEY */: {
|
|
791
|
+
return orderByKey();
|
|
792
|
+
}
|
|
793
|
+
case "orderByValue" /* ORDER_BY_VALUE */: {
|
|
794
|
+
return orderByValue();
|
|
795
|
+
}
|
|
796
|
+
case "startAt" /* START_AT */: {
|
|
797
|
+
const [[value]] = values;
|
|
798
|
+
return startAt2(value);
|
|
799
|
+
}
|
|
800
|
+
case "startAfter" /* START_AFTER */: {
|
|
801
|
+
const [[value]] = values;
|
|
802
|
+
return startAfter2(value);
|
|
803
|
+
}
|
|
804
|
+
case "endAt" /* END_AT */: {
|
|
805
|
+
const [[value]] = values;
|
|
806
|
+
return endAt2(value);
|
|
807
|
+
}
|
|
808
|
+
case "endBefore" /* END_BEFORE */: {
|
|
809
|
+
const [[value]] = values;
|
|
810
|
+
return endBefore2(value);
|
|
811
|
+
}
|
|
812
|
+
case "limitToFirst" /* LIMIT_TO_FIRST */: {
|
|
813
|
+
const [value] = values;
|
|
814
|
+
return limitToFirst(value);
|
|
815
|
+
}
|
|
816
|
+
case "limitToLast" /* LIMIT_TO_LAST */: {
|
|
817
|
+
const [value] = values;
|
|
818
|
+
return limitToLast(value);
|
|
819
|
+
}
|
|
820
|
+
case "equalTo" /* EQUAL_TO */: {
|
|
821
|
+
const [value] = values;
|
|
822
|
+
return equalTo(value);
|
|
823
|
+
}
|
|
824
|
+
default:
|
|
825
|
+
throw new Error(`Unknown method ${type}`);
|
|
826
|
+
}
|
|
827
|
+
};
|
|
828
|
+
|
|
829
|
+
// src/realtime/browser/realtime.browser.sockets.ts
|
|
830
|
+
import { getSocketAdapterBindings as getSocketAdapterBindings2 } from "@hyper-fetch/sockets";
|
|
831
|
+
import { onValue, query as query4, ref as ref2, goOffline, goOnline } from "firebase/database";
|
|
832
|
+
var realtimeSockets = (database) => {
|
|
833
|
+
return (socket) => {
|
|
834
|
+
const {
|
|
835
|
+
open,
|
|
836
|
+
connecting,
|
|
837
|
+
reconnectionAttempts,
|
|
838
|
+
listeners,
|
|
839
|
+
removeListener,
|
|
840
|
+
onConnect,
|
|
841
|
+
onReconnect,
|
|
842
|
+
onDisconnect,
|
|
843
|
+
onListen,
|
|
844
|
+
onOpen,
|
|
845
|
+
onClose,
|
|
846
|
+
onEvent,
|
|
847
|
+
onError
|
|
848
|
+
} = getSocketAdapterBindings2(socket, { open: true });
|
|
849
|
+
const connect = () => {
|
|
850
|
+
const enabled = onConnect();
|
|
851
|
+
if (enabled) {
|
|
852
|
+
goOnline(database);
|
|
853
|
+
onOpen();
|
|
854
|
+
}
|
|
855
|
+
};
|
|
856
|
+
const disconnect = () => {
|
|
857
|
+
goOffline(database);
|
|
858
|
+
onDisconnect();
|
|
859
|
+
onClose();
|
|
860
|
+
};
|
|
861
|
+
const reconnect = () => {
|
|
862
|
+
onReconnect(disconnect, connect);
|
|
863
|
+
};
|
|
864
|
+
const listen = (listener, callback) => {
|
|
865
|
+
var _a;
|
|
866
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
867
|
+
const path = ref2(database, fullUrl);
|
|
868
|
+
const { options } = listener;
|
|
869
|
+
const onlyOnce = (options == null ? void 0 : options.onlyOnce) || false;
|
|
870
|
+
const params = ((_a = options == null ? void 0 : options.constraints) == null ? void 0 : _a.map((constraint) => mapRealtimeConstraint(constraint))) || [];
|
|
871
|
+
const queryConstraints = query4(path, ...params);
|
|
872
|
+
let unsubscribe = () => {
|
|
873
|
+
};
|
|
874
|
+
let unmount = () => {
|
|
875
|
+
};
|
|
876
|
+
let clearListeners = () => {
|
|
877
|
+
};
|
|
878
|
+
unsubscribe = onValue(
|
|
879
|
+
queryConstraints,
|
|
880
|
+
(snapshot) => {
|
|
881
|
+
const response = isDocOrQuery(fullUrl) === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
882
|
+
const status = getStatus(response);
|
|
883
|
+
const extra = { ref: path, snapshot, status };
|
|
884
|
+
callback({ data: response, extra });
|
|
885
|
+
onEvent(listener.endpoint, response, extra);
|
|
886
|
+
},
|
|
887
|
+
(error) => {
|
|
888
|
+
onError(error);
|
|
889
|
+
},
|
|
890
|
+
{ onlyOnce }
|
|
891
|
+
);
|
|
892
|
+
unmount = onListen(listener, callback, unsubscribe);
|
|
893
|
+
clearListeners = () => {
|
|
894
|
+
unsubscribe();
|
|
895
|
+
unmount();
|
|
896
|
+
};
|
|
897
|
+
return clearListeners;
|
|
898
|
+
};
|
|
899
|
+
const emit = () => __async(void 0, null, function* () {
|
|
900
|
+
throw new Error("Cannot emit from Realtime database socket.");
|
|
901
|
+
});
|
|
902
|
+
return {
|
|
903
|
+
open,
|
|
904
|
+
reconnectionAttempts,
|
|
905
|
+
listeners,
|
|
906
|
+
connecting,
|
|
907
|
+
listen,
|
|
908
|
+
removeListener,
|
|
909
|
+
emit,
|
|
910
|
+
connect,
|
|
911
|
+
reconnect,
|
|
912
|
+
disconnect
|
|
913
|
+
};
|
|
914
|
+
};
|
|
915
|
+
};
|
|
916
|
+
|
|
917
|
+
// src/realtime/utils/realtime.utils.ts
|
|
918
|
+
var getOrderedResultRealtime = (snapshot) => {
|
|
919
|
+
const res = [];
|
|
920
|
+
snapshot.forEach((child) => {
|
|
921
|
+
res.push(child.val());
|
|
922
|
+
});
|
|
923
|
+
return res.length > 0 ? res : null;
|
|
924
|
+
};
|
|
925
|
+
|
|
926
|
+
// src/adapter/admin/adapter.admin.ts
|
|
927
|
+
var firebaseAdminAdapter = (database) => () => {
|
|
928
|
+
const adapter = (request, requestId) => __async(void 0, null, function* () {
|
|
929
|
+
const { fullUrl, onSuccess, onError, onRequestStart, onResponseEnd, onResponseStart, onRequestEnd } = yield getAdapterBindings(request, requestId, "error", {});
|
|
930
|
+
return new Promise((resolve) => {
|
|
931
|
+
if (database instanceof Firestore3) {
|
|
932
|
+
const {
|
|
933
|
+
method = "getDocs" /* getDocs */,
|
|
934
|
+
queryParams,
|
|
935
|
+
data,
|
|
936
|
+
options
|
|
937
|
+
} = request;
|
|
938
|
+
const availableMethods = getFirestoreAdminMethods(request, database, fullUrl, onSuccess, onError, resolve, {
|
|
939
|
+
onRequestStart,
|
|
940
|
+
onResponseEnd,
|
|
941
|
+
onResponseStart,
|
|
942
|
+
onRequestEnd
|
|
943
|
+
});
|
|
944
|
+
if (!Object.values(FirestoreMethods).includes(method)) {
|
|
945
|
+
throw new Error(`Cannot find method ${method} in Firestore available methods.`);
|
|
946
|
+
}
|
|
947
|
+
availableMethods(method, {
|
|
948
|
+
constraints: (queryParams == null ? void 0 : queryParams.constraints) ? queryParams.constraints : [],
|
|
949
|
+
data,
|
|
950
|
+
options
|
|
951
|
+
});
|
|
952
|
+
} else {
|
|
953
|
+
const {
|
|
954
|
+
method = "get" /* get */,
|
|
955
|
+
queryParams,
|
|
956
|
+
data,
|
|
957
|
+
options
|
|
958
|
+
} = request;
|
|
959
|
+
const availableMethods = getRealtimeDbAdminMethods(request, database, fullUrl, onSuccess, onError, resolve, {
|
|
960
|
+
onRequestStart,
|
|
961
|
+
onResponseEnd,
|
|
962
|
+
onResponseStart,
|
|
963
|
+
onRequestEnd
|
|
964
|
+
});
|
|
965
|
+
if (!Object.values(RealtimeDBMethods).includes(method)) {
|
|
966
|
+
throw new Error(`Cannot find method ${method} in Realtime database available methods.`);
|
|
967
|
+
}
|
|
968
|
+
availableMethods(method, {
|
|
969
|
+
constraints: (queryParams == null ? void 0 : queryParams.constraints) ? queryParams.constraints : [],
|
|
970
|
+
options,
|
|
971
|
+
data
|
|
972
|
+
});
|
|
973
|
+
}
|
|
974
|
+
});
|
|
975
|
+
});
|
|
976
|
+
return adapter;
|
|
977
|
+
};
|
|
978
|
+
|
|
979
|
+
// src/adapter/admin/adapter.admin.sockets.ts
|
|
980
|
+
import { Firestore as Firestore5 } from "firebase-admin/firestore";
|
|
981
|
+
|
|
982
|
+
// src/realtime/admin/realtime.admin.sockets.ts
|
|
983
|
+
import { getSocketAdapterBindings as getSocketAdapterBindings3 } from "@hyper-fetch/sockets";
|
|
984
|
+
var realtimeSocketsAdmin = (database) => {
|
|
985
|
+
return (socket) => {
|
|
986
|
+
const {
|
|
987
|
+
open,
|
|
988
|
+
connecting,
|
|
989
|
+
reconnectionAttempts,
|
|
990
|
+
listeners,
|
|
991
|
+
removeListener,
|
|
992
|
+
onConnect,
|
|
993
|
+
onReconnect,
|
|
994
|
+
onDisconnect,
|
|
995
|
+
onListen,
|
|
996
|
+
onOpen,
|
|
997
|
+
onClose,
|
|
998
|
+
onEvent,
|
|
999
|
+
onError
|
|
1000
|
+
} = getSocketAdapterBindings3(socket, { open: true });
|
|
1001
|
+
const connect = () => {
|
|
1002
|
+
const enabled = onConnect();
|
|
1003
|
+
if (enabled) {
|
|
1004
|
+
database.goOnline();
|
|
1005
|
+
onOpen();
|
|
1006
|
+
}
|
|
1007
|
+
};
|
|
1008
|
+
const disconnect = () => {
|
|
1009
|
+
database.goOffline();
|
|
1010
|
+
onDisconnect();
|
|
1011
|
+
onClose();
|
|
1012
|
+
};
|
|
1013
|
+
const reconnect = () => {
|
|
1014
|
+
onReconnect(disconnect, connect);
|
|
1015
|
+
};
|
|
1016
|
+
const listen = (listener, callback) => {
|
|
1017
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
1018
|
+
const path = database.ref(fullUrl);
|
|
1019
|
+
const { options } = listener;
|
|
1020
|
+
const onlyOnce = (options == null ? void 0 : options.onlyOnce) || false;
|
|
1021
|
+
const q = applyRealtimeAdminConstraints(path, (options == null ? void 0 : options.constraints) || []);
|
|
1022
|
+
const method = onlyOnce === true ? "once" : "on";
|
|
1023
|
+
q[method](
|
|
1024
|
+
"value",
|
|
1025
|
+
(snapshot) => {
|
|
1026
|
+
const response = isDocOrQuery(fullUrl) === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
1027
|
+
const status = getStatus(response);
|
|
1028
|
+
const extra = { ref: path, snapshot, status };
|
|
1029
|
+
callback({ data: response, extra });
|
|
1030
|
+
onEvent(listener.endpoint, response, extra);
|
|
1031
|
+
},
|
|
1032
|
+
(error) => {
|
|
1033
|
+
onError(error);
|
|
1034
|
+
}
|
|
1035
|
+
);
|
|
1036
|
+
const unsubscribe = () => q.off("value");
|
|
1037
|
+
const unmount = onListen(listener, callback, unsubscribe);
|
|
1038
|
+
const clearListeners = () => {
|
|
1039
|
+
unsubscribe();
|
|
1040
|
+
unmount();
|
|
1041
|
+
};
|
|
1042
|
+
return clearListeners;
|
|
1043
|
+
};
|
|
1044
|
+
const emit = () => __async(void 0, null, function* () {
|
|
1045
|
+
throw new Error("Cannot emit from Realtime database socket.");
|
|
1046
|
+
});
|
|
1047
|
+
return {
|
|
1048
|
+
open,
|
|
1049
|
+
reconnectionAttempts,
|
|
1050
|
+
listeners,
|
|
1051
|
+
connecting,
|
|
1052
|
+
listen,
|
|
1053
|
+
removeListener,
|
|
1054
|
+
emit,
|
|
1055
|
+
connect,
|
|
1056
|
+
reconnect,
|
|
1057
|
+
disconnect
|
|
1058
|
+
};
|
|
1059
|
+
};
|
|
1060
|
+
};
|
|
1061
|
+
|
|
1062
|
+
// src/firestore/admin/firestore.admin.sockets.ts
|
|
1063
|
+
import { CollectionReference, DocumentSnapshot } from "firebase-admin/firestore";
|
|
1064
|
+
import { getSocketAdapterBindings as getSocketAdapterBindings4 } from "@hyper-fetch/sockets";
|
|
1065
|
+
var firestoreAdminSockets = (database) => {
|
|
1066
|
+
return (socket) => {
|
|
1067
|
+
const {
|
|
1068
|
+
open,
|
|
1069
|
+
connecting,
|
|
1070
|
+
reconnectionAttempts,
|
|
1071
|
+
listeners,
|
|
1072
|
+
removeListener,
|
|
1073
|
+
onReconnect,
|
|
1074
|
+
onListen,
|
|
1075
|
+
onEvent,
|
|
1076
|
+
onError
|
|
1077
|
+
} = getSocketAdapterBindings4(socket, { open: true });
|
|
1078
|
+
const connect = () => {
|
|
1079
|
+
throw new Error("Connect function is not implemented for Firestore Admin socket.");
|
|
1080
|
+
};
|
|
1081
|
+
const disconnect = () => {
|
|
1082
|
+
throw new Error("Cannot disconnect from Firestore database socket. Use 'app.delete()' instead.");
|
|
1083
|
+
};
|
|
1084
|
+
const reconnect = () => {
|
|
1085
|
+
onReconnect(disconnect, connect);
|
|
1086
|
+
};
|
|
1087
|
+
const listen = (listener, callback) => {
|
|
1088
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
1089
|
+
const { options } = listener;
|
|
1090
|
+
let pathRef = getRef(database, fullUrl);
|
|
1091
|
+
if (pathRef instanceof CollectionReference) {
|
|
1092
|
+
pathRef = applyFireStoreAdminConstraints(pathRef, (options == null ? void 0 : options.constraints) || []);
|
|
1093
|
+
}
|
|
1094
|
+
let unsubscribe = () => {
|
|
1095
|
+
};
|
|
1096
|
+
let unmount = () => {
|
|
1097
|
+
};
|
|
1098
|
+
let clearListeners = () => {
|
|
1099
|
+
};
|
|
1100
|
+
unsubscribe = pathRef.onSnapshot(
|
|
1101
|
+
(snapshot) => {
|
|
1102
|
+
const response = snapshot instanceof DocumentSnapshot ? snapshot.data() || null : getOrderedResultFirestore(snapshot);
|
|
1103
|
+
const status = getStatus(response);
|
|
1104
|
+
const groupedResult = (options == null ? void 0 : options.groupByChangeType) === true ? getGroupedResultFirestore(snapshot) : null;
|
|
1105
|
+
const extra = { ref: pathRef, snapshot, unsubscribe, groupedResult, status };
|
|
1106
|
+
callback({ data: response, extra });
|
|
1107
|
+
onEvent(listener.endpoint, response, extra);
|
|
1108
|
+
},
|
|
1109
|
+
(error) => {
|
|
1110
|
+
onError(error);
|
|
1111
|
+
}
|
|
1112
|
+
);
|
|
1113
|
+
unmount = onListen(listener, callback, unsubscribe);
|
|
1114
|
+
clearListeners = () => {
|
|
1115
|
+
unsubscribe();
|
|
1116
|
+
unmount();
|
|
1117
|
+
};
|
|
1118
|
+
return clearListeners;
|
|
1119
|
+
};
|
|
1120
|
+
const emit = () => __async(void 0, null, function* () {
|
|
1121
|
+
throw new Error("Cannot emit from Firestore database socket.");
|
|
1122
|
+
});
|
|
1123
|
+
return {
|
|
1124
|
+
open,
|
|
1125
|
+
reconnectionAttempts,
|
|
1126
|
+
listeners,
|
|
1127
|
+
connecting,
|
|
1128
|
+
listen,
|
|
1129
|
+
removeListener,
|
|
1130
|
+
emit,
|
|
1131
|
+
connect,
|
|
1132
|
+
reconnect,
|
|
1133
|
+
disconnect
|
|
1134
|
+
};
|
|
1135
|
+
};
|
|
1136
|
+
};
|
|
1137
|
+
|
|
1138
|
+
// src/adapter/admin/adapter.admin.sockets.ts
|
|
1139
|
+
var firebaseSocketsAdminAdapter = (database) => {
|
|
1140
|
+
if (database instanceof Firestore5) {
|
|
1141
|
+
return firestoreAdminSockets(database);
|
|
1142
|
+
}
|
|
1143
|
+
return realtimeSocketsAdmin(database);
|
|
1144
|
+
};
|
|
1145
|
+
|
|
1146
|
+
// src/adapter/browser/adapter.browser.ts
|
|
1147
|
+
import { getAdapterBindings as getAdapterBindings2 } from "@hyper-fetch/core";
|
|
1148
|
+
import { Database as Database3 } from "firebase/database";
|
|
1149
|
+
var firebaseAdapter = (database) => () => {
|
|
1150
|
+
const adapter = (request, requestId) => __async(void 0, null, function* () {
|
|
1151
|
+
const { fullUrl, onSuccess, onError, onResponseStart, onResponseEnd, onRequestStart, onRequestEnd } = yield getAdapterBindings2(request, requestId, "error", {});
|
|
1152
|
+
return new Promise((resolve) => {
|
|
1153
|
+
if (database instanceof Database3) {
|
|
1154
|
+
const {
|
|
1155
|
+
method = "get" /* get */,
|
|
1156
|
+
queryParams,
|
|
1157
|
+
data,
|
|
1158
|
+
options
|
|
1159
|
+
} = request;
|
|
1160
|
+
const availableMethods = getRealtimeDbBrowserMethods(
|
|
1161
|
+
request,
|
|
1162
|
+
database,
|
|
1163
|
+
fullUrl,
|
|
1164
|
+
onSuccess,
|
|
1165
|
+
onError,
|
|
1166
|
+
resolve,
|
|
1167
|
+
{
|
|
1168
|
+
onResponseStart,
|
|
1169
|
+
onResponseEnd,
|
|
1170
|
+
onRequestStart,
|
|
1171
|
+
onRequestEnd
|
|
1172
|
+
}
|
|
1173
|
+
);
|
|
1174
|
+
if (!Object.values(RealtimeDBMethods).includes(method)) {
|
|
1175
|
+
throw new Error(`Cannot find method ${method} in Realtime database available methods.`);
|
|
1176
|
+
}
|
|
1177
|
+
availableMethods(method, {
|
|
1178
|
+
constraints: (queryParams == null ? void 0 : queryParams.constraints) || [],
|
|
1179
|
+
options,
|
|
1180
|
+
data
|
|
1181
|
+
});
|
|
1182
|
+
} else {
|
|
1183
|
+
const {
|
|
1184
|
+
method = "getDocs" /* getDocs */,
|
|
1185
|
+
queryParams,
|
|
1186
|
+
data,
|
|
1187
|
+
options
|
|
1188
|
+
} = request;
|
|
1189
|
+
const availableMethods = getFirestoreBrowserMethods(request, database, fullUrl, onSuccess, onError, resolve, {
|
|
1190
|
+
onResponseStart,
|
|
1191
|
+
onResponseEnd,
|
|
1192
|
+
onRequestStart,
|
|
1193
|
+
onRequestEnd
|
|
1194
|
+
});
|
|
1195
|
+
if (!Object.values(FirestoreMethods).includes(method)) {
|
|
1196
|
+
throw new Error(`Cannot find method ${method} in Firestore available methods.`);
|
|
1197
|
+
}
|
|
1198
|
+
availableMethods(method, {
|
|
1199
|
+
constraints: (queryParams == null ? void 0 : queryParams.constraints) ? queryParams.constraints : [],
|
|
1200
|
+
data,
|
|
1201
|
+
options
|
|
1202
|
+
});
|
|
1203
|
+
}
|
|
1204
|
+
});
|
|
1205
|
+
});
|
|
1206
|
+
return adapter;
|
|
1207
|
+
};
|
|
1208
|
+
|
|
1209
|
+
// src/adapter/browser/adapter.browser.sockets.ts
|
|
1210
|
+
import { Database as Database4 } from "firebase/database";
|
|
1211
|
+
import { Firestore as Firestore6 } from "firebase/firestore";
|
|
1212
|
+
var firebaseSocketsAdapter = (database) => {
|
|
1213
|
+
if (database instanceof Database4) {
|
|
1214
|
+
return realtimeSockets(database);
|
|
1215
|
+
}
|
|
1216
|
+
if (database instanceof Firestore6) {
|
|
1217
|
+
return firestoreSockets(database);
|
|
1218
|
+
}
|
|
1219
|
+
throw new Error("Unknown database type");
|
|
1220
|
+
};
|
|
1221
|
+
|
|
1222
|
+
// src/index.ts
|
|
1223
|
+
__reExport(src_exports, __toESM(require_methods()));
|
|
1224
|
+
export {
|
|
1225
|
+
$endAt,
|
|
1226
|
+
$endBefore,
|
|
1227
|
+
$equalTo,
|
|
1228
|
+
$limit,
|
|
1229
|
+
$limitToFirst,
|
|
1230
|
+
$limitToLast,
|
|
1231
|
+
$orderBy,
|
|
1232
|
+
$orderByChild,
|
|
1233
|
+
$orderByKey,
|
|
1234
|
+
$orderByValue,
|
|
1235
|
+
$startAfter,
|
|
1236
|
+
$startAt,
|
|
1237
|
+
$where,
|
|
1238
|
+
FirestoreMethods,
|
|
1239
|
+
FirestoreQueryConstraints,
|
|
1240
|
+
RealtimeDBMethods,
|
|
1241
|
+
RealtimeQueryConstraints,
|
|
1242
|
+
SharedQueryConstraints,
|
|
1243
|
+
applyFireStoreAdminConstraint,
|
|
1244
|
+
applyFireStoreAdminConstraints,
|
|
1245
|
+
applyRealtimeAdminConstraint,
|
|
1246
|
+
applyRealtimeAdminConstraints,
|
|
1247
|
+
firebaseAdapter,
|
|
1248
|
+
firebaseAdminAdapter,
|
|
1249
|
+
firebaseSocketsAdapter,
|
|
1250
|
+
firebaseSocketsAdminAdapter,
|
|
1251
|
+
firestoreSockets,
|
|
1252
|
+
getFirestoreAdminMethods,
|
|
1253
|
+
getFirestoreBrowserMethods,
|
|
1254
|
+
getGroupedResultFirestore,
|
|
1255
|
+
getOrderedResultFirestore,
|
|
1256
|
+
getOrderedResultRealtime,
|
|
1257
|
+
getRealtimeDbAdminMethods,
|
|
1258
|
+
getRealtimeDbBrowserMethods,
|
|
1259
|
+
getRef,
|
|
1260
|
+
mapConstraint,
|
|
1261
|
+
mapRealtimeConstraint,
|
|
1262
|
+
realtimeSockets
|
|
1263
|
+
};
|
|
1264
|
+
/*!
|
|
1265
|
+
* methods
|
|
1266
|
+
* Copyright(c) 2013-2014 TJ Holowaychuk
|
|
1267
|
+
* Copyright(c) 2015-2016 Douglas Christopher Wilson
|
|
1268
|
+
* MIT Licensed
|
|
1269
|
+
*/
|
|
1270
|
+
//# sourceMappingURL=index.esm.js.map
|