301 lines
8 KiB
JavaScript
301 lines
8 KiB
JavaScript
// Module ID: 588
|
|
// Function ID: 6980
|
|
// Name: parseValue
|
|
// Dependencies: []
|
|
|
|
// Module 588 (parseValue)
|
|
function parseValue(arg0) {
|
|
let parsed = arg0;
|
|
if (null != arg0) {
|
|
const _JSON = JSON;
|
|
parsed = JSON.parse(parsed);
|
|
}
|
|
}
|
|
let closure_2 = importDefault(dependencyMap[0]);
|
|
let closure_3 = importDefault(dependencyMap[1]);
|
|
let closure_4 = importDefault(dependencyMap[2]);
|
|
let closure_5 = importDefault(dependencyMap[4]);
|
|
const DCDStrongboxManager = arg1(dependencyMap[3]).NativeModules.DCDStrongboxManager;
|
|
let tmp3 = () => {
|
|
class ProxyAsyncStorage {
|
|
constructor() {
|
|
f7001 = this;
|
|
tmp = closure_3(this, ProxyAsyncStorage);
|
|
promise = new Promise((parseResolve) => {
|
|
self.parseResolve = parseResolve;
|
|
});
|
|
this.parsePromise = promise;
|
|
this.storage = {};
|
|
set = new Set();
|
|
this.secureKeys = set;
|
|
this.hasLoaded = false;
|
|
return;
|
|
}
|
|
}
|
|
const callback = ProxyAsyncStorage;
|
|
let obj = {
|
|
key: "refresh",
|
|
value() {
|
|
let items = arg0;
|
|
const self = this;
|
|
let closure_0 = this;
|
|
if (arg0 === undefined) {
|
|
items = [];
|
|
}
|
|
if (arg1 === undefined) {
|
|
const _Set = Set;
|
|
new Set();
|
|
}
|
|
self.secureKeys = new Set();
|
|
const items1 = [store.refresh(items), ];
|
|
let refreshResult;
|
|
if (null != store2) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(self.secureKeys, 0);
|
|
refreshResult = store2.refresh(items2);
|
|
}
|
|
items1[1] = refreshResult;
|
|
const set1 = new Set();
|
|
return Promise.all(items1).then((arg0) => {
|
|
let tmp2;
|
|
let tmp3;
|
|
[tmp2, tmp3] = arg0;
|
|
self(closure_1[5]).mark("\u{1F4BE}", "Storage.refresh() Promise Resolved");
|
|
let num = 0;
|
|
let num2 = 0;
|
|
const keys = Object.keys();
|
|
if (keys !== undefined) {
|
|
num2 = num;
|
|
while (keys[tmp] !== undefined) {
|
|
let tmp11 = tmp6;
|
|
let length = tmp2[tmp6].length;
|
|
let sum = num + length;
|
|
num = sum;
|
|
if (length <= 10000) {
|
|
continue;
|
|
} else {
|
|
let tmp7 = self;
|
|
let tmp8 = closure_1;
|
|
let obj2 = self(closure_1[5]);
|
|
let addDetailResult = obj2.addDetail(tmp6, length);
|
|
num = sum;
|
|
// continue
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
const obj = self(closure_1[5]);
|
|
self(closure_1[5]).addDetail("TotalStorageSize", num2);
|
|
self.hasLoaded = true;
|
|
const items = [tmp2, tmp3];
|
|
return items;
|
|
});
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , ];
|
|
obj = {
|
|
key: "parse",
|
|
value(arg0) {
|
|
let tmp;
|
|
let tmp2;
|
|
const self = this;
|
|
const callback = this;
|
|
[tmp, tmp2] = arg0;
|
|
callback(closure_1[6])(tmp2, (rawData) => {
|
|
self.storage[arg1] = { parsed: false, rawData };
|
|
});
|
|
callback(closure_1[6])(tmp, (rawData) => {
|
|
self.storage[arg1] = { parsed: false, rawData };
|
|
const secureKeys = self.secureKeys;
|
|
if (secureKeys.has(arg1)) {
|
|
function migrateToStrongbox(arg0, rawData) {
|
|
const result = item.setItem(arg0, rawData);
|
|
result.then((arg0) => {
|
|
if (arg0) {
|
|
closure_5.removeItem(arg0);
|
|
}
|
|
});
|
|
}(arg1, rawData);
|
|
}
|
|
});
|
|
self.parseResolve();
|
|
return Promise.resolve();
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "get",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
const storage = this.storage;
|
|
if (storage.hasOwnProperty(arg0)) {
|
|
let iter = tmp2;
|
|
if (!self.storage[arg0].parsed) {
|
|
const obj = { parsed: true, value: callback4(tmp2.rawData) };
|
|
self.storage[arg0] = obj;
|
|
iter = obj;
|
|
}
|
|
return iter.value;
|
|
} else {
|
|
return arg1;
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
const obj1 = { key: "getAfterRefresh" };
|
|
let closure_1 = callback(async function(arg0) {
|
|
const self = this;
|
|
return yield self.parsePromise.then(() => self.get(arg0));
|
|
});
|
|
obj1.value = function getAfterRefresh(arg0) {
|
|
return callback2(...arguments);
|
|
};
|
|
items[3] = obj1;
|
|
items[4] = {
|
|
key: "asyncGet",
|
|
value(arg0, arg1, arg2) {
|
|
let closure_0 = this;
|
|
let closure_1 = arg0;
|
|
const ProxyAsyncStorage = arg1;
|
|
function handleCallback(arg0, arg1) {
|
|
if (null != arg1) {
|
|
const _Date = Date;
|
|
const timestamp = Date.now();
|
|
const tmp6 = callback(arg1);
|
|
const obj = { parsed: true, value: tmp6 };
|
|
self.storage[arg0] = obj;
|
|
const _Date2 = Date;
|
|
if (null != arg2) {
|
|
self(arg0[5]).mark("\u{1F4BE}", arg2, tmp9);
|
|
const obj2 = self(arg0[5]);
|
|
}
|
|
arg1(tmp6);
|
|
} else {
|
|
arg1(null);
|
|
}
|
|
}
|
|
const secureKeys = this.secureKeys;
|
|
if (secureKeys.has(arg0)) {
|
|
let value = store2.getItem(arg0);
|
|
value.then((arg0) => {
|
|
handleCallback(arg0, arg0);
|
|
});
|
|
} else {
|
|
value = store.getItem(arg0);
|
|
value.then((arg0) => {
|
|
handleCallback(arg0, arg0);
|
|
});
|
|
}
|
|
}
|
|
};
|
|
const obj3 = { key: "asyncGetRaw" };
|
|
let closure_0 = callback(async function(arg0, arg1) {
|
|
if (null != arg1) {
|
|
callback(closure_1[5]).mark("\u{1F4BE}", `Get: ${arg1}`);
|
|
const obj = callback(closure_1[5]);
|
|
}
|
|
const secureKeys = this.secureKeys;
|
|
if (secureKeys.has(arg0)) {
|
|
let value = item2.getItem(arg0);
|
|
} else {
|
|
value = item.getItem(arg0);
|
|
}
|
|
const tmp7 = yield value;
|
|
let tmp8 = null;
|
|
if (null != tmp7) {
|
|
tmp8 = tmp7;
|
|
if (null != arg1) {
|
|
callback(closure_1[5]).mark("\u{1F4BE}", `Got: ${arg1}`);
|
|
tmp8 = tmp7;
|
|
const obj2 = callback(closure_1[5]);
|
|
}
|
|
}
|
|
return tmp8;
|
|
});
|
|
obj3.value = function asyncGetRaw() {
|
|
return callback(...arguments);
|
|
};
|
|
items[5] = obj3;
|
|
items[6] = {
|
|
key: "getRaw",
|
|
value(arg0) {
|
|
const storage = this.storage;
|
|
if (storage.hasOwnProperty(arg0)) {
|
|
const tmp = this.storage[arg0];
|
|
let tmp2 = null;
|
|
if (!tmp.parsed) {
|
|
const rawData = tmp.rawData;
|
|
let tmp3 = null;
|
|
if (null != rawData) {
|
|
tmp3 = rawData;
|
|
}
|
|
tmp2 = tmp3;
|
|
}
|
|
return tmp2;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "set",
|
|
value(arg0, value) {
|
|
this.setRaw(arg0, JSON.stringify(value));
|
|
this.storage[arg0] = { parsed: true, value };
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "setRaw",
|
|
value(arg0, rawData) {
|
|
const self = this;
|
|
if ("string" !== typeof arg0) {
|
|
const _Error2 = Error;
|
|
const error = new Error("Key must be a string");
|
|
throw error;
|
|
} else if ("string" !== typeof rawData) {
|
|
const _Error = Error;
|
|
const error1 = new Error("value must be a string");
|
|
throw error1;
|
|
} else {
|
|
const obj = { parsed: false, rawData };
|
|
self.storage[arg0] = obj;
|
|
const secureKeys = self.secureKeys;
|
|
if (secureKeys.has(arg0)) {
|
|
const result = store2.setItem(arg0, rawData);
|
|
} else {
|
|
const result1 = store.setItem(arg0, rawData);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "remove",
|
|
value(arg0) {
|
|
delete r1[r2];
|
|
const secureKeys = this.secureKeys;
|
|
if (secureKeys.has(arg0)) {
|
|
store2.removeItem(arg0);
|
|
} else {
|
|
store.removeItem(arg0);
|
|
}
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "clear",
|
|
value() {
|
|
this.storage = {};
|
|
store.clear();
|
|
if (null != store2) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(this.secureKeys, 0);
|
|
store2.clear(items);
|
|
}
|
|
}
|
|
};
|
|
return callback2(ProxyAsyncStorage, items);
|
|
}();
|
|
tmp3 = new tmp3();
|
|
const tmp2 = arg1(dependencyMap[3]);
|
|
const result = arg1(dependencyMap[7]).fileFinishedImporting("../discord_common/js/packages/storage/native/Storage.tsx");
|
|
|
|
export const impl = tmp3;
|