|
function _regeneratorRuntime() { |
|
_regeneratorRuntime = function () { |
|
return exports; |
|
}; |
|
var exports = {}, |
|
Op = Object.prototype, |
|
hasOwn = Op.hasOwnProperty, |
|
defineProperty = Object.defineProperty || function (obj, key, desc) { |
|
obj[key] = desc.value; |
|
}, |
|
$Symbol = "function" == typeof Symbol ? Symbol : {}, |
|
iteratorSymbol = $Symbol.iterator || "@@iterator", |
|
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", |
|
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; |
|
function define(obj, key, value) { |
|
return Object.defineProperty(obj, key, { |
|
value: value, |
|
enumerable: !0, |
|
configurable: !0, |
|
writable: !0 |
|
}), obj[key]; |
|
} |
|
try { |
|
define({}, ""); |
|
} catch (err) { |
|
define = function (obj, key, value) { |
|
return obj[key] = value; |
|
}; |
|
} |
|
function wrap(innerFn, outerFn, self, tryLocsList) { |
|
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, |
|
generator = Object.create(protoGenerator.prototype), |
|
context = new Context(tryLocsList || []); |
|
return defineProperty(generator, "_invoke", { |
|
value: makeInvokeMethod(innerFn, self, context) |
|
}), generator; |
|
} |
|
function tryCatch(fn, obj, arg) { |
|
try { |
|
return { |
|
type: "normal", |
|
arg: fn.call(obj, arg) |
|
}; |
|
} catch (err) { |
|
return { |
|
type: "throw", |
|
arg: err |
|
}; |
|
} |
|
} |
|
exports.wrap = wrap; |
|
var ContinueSentinel = {}; |
|
function Generator() {} |
|
function GeneratorFunction() {} |
|
function GeneratorFunctionPrototype() {} |
|
var IteratorPrototype = {}; |
|
define(IteratorPrototype, iteratorSymbol, function () { |
|
return this; |
|
}); |
|
var getProto = Object.getPrototypeOf, |
|
NativeIteratorPrototype = getProto && getProto(getProto(values([]))); |
|
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); |
|
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); |
|
function defineIteratorMethods(prototype) { |
|
["next", "throw", "return"].forEach(function (method) { |
|
define(prototype, method, function (arg) { |
|
return this._invoke(method, arg); |
|
}); |
|
}); |
|
} |
|
function AsyncIterator(generator, PromiseImpl) { |
|
function invoke(method, arg, resolve, reject) { |
|
var record = tryCatch(generator[method], generator, arg); |
|
if ("throw" !== record.type) { |
|
var result = record.arg, |
|
value = result.value; |
|
return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { |
|
invoke("next", value, resolve, reject); |
|
}, function (err) { |
|
invoke("throw", err, resolve, reject); |
|
}) : PromiseImpl.resolve(value).then(function (unwrapped) { |
|
result.value = unwrapped, resolve(result); |
|
}, function (error) { |
|
return invoke("throw", error, resolve, reject); |
|
}); |
|
} |
|
reject(record.arg); |
|
} |
|
var previousPromise; |
|
defineProperty(this, "_invoke", { |
|
value: function (method, arg) { |
|
function callInvokeWithMethodAndArg() { |
|
return new PromiseImpl(function (resolve, reject) { |
|
invoke(method, arg, resolve, reject); |
|
}); |
|
} |
|
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); |
|
} |
|
}); |
|
} |
|
function makeInvokeMethod(innerFn, self, context) { |
|
var state = "suspendedStart"; |
|
return function (method, arg) { |
|
if ("executing" === state) throw new Error("Generator is already running"); |
|
if ("completed" === state) { |
|
if ("throw" === method) throw arg; |
|
return doneResult(); |
|
} |
|
for (context.method = method, context.arg = arg;;) { |
|
var delegate = context.delegate; |
|
if (delegate) { |
|
var delegateResult = maybeInvokeDelegate(delegate, context); |
|
if (delegateResult) { |
|
if (delegateResult === ContinueSentinel) continue; |
|
return delegateResult; |
|
} |
|
} |
|
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { |
|
if ("suspendedStart" === state) throw state = "completed", context.arg; |
|
context.dispatchException(context.arg); |
|
} else "return" === context.method && context.abrupt("return", context.arg); |
|
state = "executing"; |
|
var record = tryCatch(innerFn, self, context); |
|
if ("normal" === record.type) { |
|
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; |
|
return { |
|
value: record.arg, |
|
done: context.done |
|
}; |
|
} |
|
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); |
|
} |
|
}; |
|
} |
|
function maybeInvokeDelegate(delegate, context) { |
|
var methodName = context.method, |
|
method = delegate.iterator[methodName]; |
|
if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; |
|
var record = tryCatch(method, delegate.iterator, context.arg); |
|
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; |
|
var info = record.arg; |
|
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); |
|
} |
|
function pushTryEntry(locs) { |
|
var entry = { |
|
tryLoc: locs[0] |
|
}; |
|
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); |
|
} |
|
function resetTryEntry(entry) { |
|
var record = entry.completion || {}; |
|
record.type = "normal", delete record.arg, entry.completion = record; |
|
} |
|
function Context(tryLocsList) { |
|
this.tryEntries = [{ |
|
tryLoc: "root" |
|
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); |
|
} |
|
function values(iterable) { |
|
if (iterable) { |
|
var iteratorMethod = iterable[iteratorSymbol]; |
|
if (iteratorMethod) return iteratorMethod.call(iterable); |
|
if ("function" == typeof iterable.next) return iterable; |
|
if (!isNaN(iterable.length)) { |
|
var i = -1, |
|
next = function next() { |
|
for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; |
|
return next.value = undefined, next.done = !0, next; |
|
}; |
|
return next.next = next; |
|
} |
|
} |
|
return { |
|
next: doneResult |
|
}; |
|
} |
|
function doneResult() { |
|
return { |
|
value: undefined, |
|
done: !0 |
|
}; |
|
} |
|
return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { |
|
value: GeneratorFunctionPrototype, |
|
configurable: !0 |
|
}), defineProperty(GeneratorFunctionPrototype, "constructor", { |
|
value: GeneratorFunction, |
|
configurable: !0 |
|
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { |
|
var ctor = "function" == typeof genFun && genFun.constructor; |
|
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); |
|
}, exports.mark = function (genFun) { |
|
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; |
|
}, exports.awrap = function (arg) { |
|
return { |
|
__await: arg |
|
}; |
|
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { |
|
return this; |
|
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { |
|
void 0 === PromiseImpl && (PromiseImpl = Promise); |
|
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); |
|
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { |
|
return result.done ? result.value : iter.next(); |
|
}); |
|
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { |
|
return this; |
|
}), define(Gp, "toString", function () { |
|
return "[object Generator]"; |
|
}), exports.keys = function (val) { |
|
var object = Object(val), |
|
keys = []; |
|
for (var key in object) keys.push(key); |
|
return keys.reverse(), function next() { |
|
for (; keys.length;) { |
|
var key = keys.pop(); |
|
if (key in object) return next.value = key, next.done = !1, next; |
|
} |
|
return next.done = !0, next; |
|
}; |
|
}, exports.values = values, Context.prototype = { |
|
constructor: Context, |
|
reset: function (skipTempReset) { |
|
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); |
|
}, |
|
stop: function () { |
|
this.done = !0; |
|
var rootRecord = this.tryEntries[0].completion; |
|
if ("throw" === rootRecord.type) throw rootRecord.arg; |
|
return this.rval; |
|
}, |
|
dispatchException: function (exception) { |
|
if (this.done) throw exception; |
|
var context = this; |
|
function handle(loc, caught) { |
|
return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; |
|
} |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i], |
|
record = entry.completion; |
|
if ("root" === entry.tryLoc) return handle("end"); |
|
if (entry.tryLoc <= this.prev) { |
|
var hasCatch = hasOwn.call(entry, "catchLoc"), |
|
hasFinally = hasOwn.call(entry, "finallyLoc"); |
|
if (hasCatch && hasFinally) { |
|
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); |
|
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); |
|
} else if (hasCatch) { |
|
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); |
|
} else { |
|
if (!hasFinally) throw new Error("try statement without catch or finally"); |
|
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); |
|
} |
|
} |
|
} |
|
}, |
|
abrupt: function (type, arg) { |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { |
|
var finallyEntry = entry; |
|
break; |
|
} |
|
} |
|
finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); |
|
var record = finallyEntry ? finallyEntry.completion : {}; |
|
return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); |
|
}, |
|
complete: function (record, afterLoc) { |
|
if ("throw" === record.type) throw record.arg; |
|
return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; |
|
}, |
|
finish: function (finallyLoc) { |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; |
|
} |
|
}, |
|
catch: function (tryLoc) { |
|
for (var i = this.tryEntries.length - 1; i >= 0; --i) { |
|
var entry = this.tryEntries[i]; |
|
if (entry.tryLoc === tryLoc) { |
|
var record = entry.completion; |
|
if ("throw" === record.type) { |
|
var thrown = record.arg; |
|
resetTryEntry(entry); |
|
} |
|
return thrown; |
|
} |
|
} |
|
throw new Error("illegal catch attempt"); |
|
}, |
|
delegateYield: function (iterable, resultName, nextLoc) { |
|
return this.delegate = { |
|
iterator: values(iterable), |
|
resultName: resultName, |
|
nextLoc: nextLoc |
|
}, "next" === this.method && (this.arg = undefined), ContinueSentinel; |
|
} |
|
}, exports; |
|
} |
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { |
|
try { |
|
var info = gen[key](arg); |
|
var value = info.value; |
|
} catch (error) { |
|
reject(error); |
|
return; |
|
} |
|
if (info.done) { |
|
resolve(value); |
|
} else { |
|
Promise.resolve(value).then(_next, _throw); |
|
} |
|
} |
|
function _asyncToGenerator(fn) { |
|
return function () { |
|
var self = this, |
|
args = arguments; |
|
return new Promise(function (resolve, reject) { |
|
var gen = fn.apply(self, args); |
|
function _next(value) { |
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); |
|
} |
|
function _throw(err) { |
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); |
|
} |
|
_next(undefined); |
|
}); |
|
}; |
|
} |
|
function _extends() { |
|
_extends = Object.assign ? Object.assign.bind() : function (target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i]; |
|
for (var key in source) { |
|
if (Object.prototype.hasOwnProperty.call(source, key)) { |
|
target[key] = source[key]; |
|
} |
|
} |
|
} |
|
return target; |
|
}; |
|
return _extends.apply(this, arguments); |
|
} |
|
|
|
var ChatGptAPI = function ChatGptAPI() {}; |
|
ChatGptAPI.fetchChatById = /*#__PURE__*/function () { |
|
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(id) { |
|
var chat, chatJson; |
|
return _regeneratorRuntime().wrap(function _callee$(_context) { |
|
while (1) switch (_context.prev = _context.next) { |
|
case 0: |
|
_context.next = 2; |
|
return fetch("https://chat.openai.com/backend-api/conversation/" + id, { |
|
headers: { |
|
accept: '*/*', |
|
'accept-language': 'en-US,en;q=0.9', |
|
authorization: 'Bearer ', |
|
'cache-control': 'no-cache', |
|
'content-type': 'application/json', |
|
pragma: 'no-cache', |
|
'sec-ch-ua': '"Chromium";v="110", "Not A(Brand";v="24", "Google Chrome";v="110"', |
|
'sec-ch-ua-mobile': '?0', |
|
'sec-ch-ua-platform': '"macOS"', |
|
'sec-fetch-dest': 'empty', |
|
'sec-fetch-mode': 'cors', |
|
'sec-fetch-site': 'same-origin' |
|
}, |
|
referrer: 'https://chat.openai.com/chat/94b7cc88-33cb-4f06-b172-431a40436738', |
|
referrerPolicy: 'same-origin', |
|
body: null, |
|
method: 'GET', |
|
mode: 'cors', |
|
credentials: 'include' |
|
}); |
|
case 2: |
|
chat = _context.sent; |
|
_context.next = 5; |
|
return chat.json(); |
|
case 5: |
|
chatJson = _context.sent; |
|
return _context.abrupt("return", chatJson); |
|
case 7: |
|
case "end": |
|
return _context.stop(); |
|
} |
|
}, _callee); |
|
})); |
|
return function (_x) { |
|
return _ref.apply(this, arguments); |
|
}; |
|
}(); |
|
ChatGptAPI.fetchChatHistory = /*#__PURE__*/function () { |
|
var _ref2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(offset, limit) { |
|
var chatHistory, chatHistoryJson; |
|
return _regeneratorRuntime().wrap(function _callee2$(_context2) { |
|
while (1) switch (_context2.prev = _context2.next) { |
|
case 0: |
|
_context2.next = 2; |
|
return fetch("https://chat.openai.com/backend-api/conversations?limit=" + limit + "&offset=" + offset, { |
|
headers: { |
|
accept: '*/*', |
|
'accept-language': 'en-US,en;q=0.9', |
|
authorization: 'Bearer ', |
|
'cache-control': 'no-cache', |
|
'content-type': 'application/json', |
|
pragma: 'no-cache', |
|
'sec-ch-ua': '"Chromium";v="110", "Not A(Brand";v="24", "Google Chrome";v="110"', |
|
'sec-ch-ua-mobile': '?0', |
|
'sec-ch-ua-platform': '"macOS"', |
|
'sec-fetch-dest': 'empty', |
|
'sec-fetch-mode': 'cors', |
|
'sec-fetch-site': 'same-origin' |
|
}, |
|
referrer: 'https://chat.openai.com/chat', |
|
referrerPolicy: 'same-origin', |
|
body: null, |
|
method: 'GET', |
|
mode: 'cors', |
|
credentials: 'include' |
|
}); |
|
case 2: |
|
chatHistory = _context2.sent; |
|
_context2.next = 5; |
|
return chatHistory.json(); |
|
case 5: |
|
chatHistoryJson = _context2.sent; |
|
console.log({ |
|
chatHistoryJson: chatHistoryJson |
|
}); |
|
return _context2.abrupt("return", chatHistoryJson); |
|
case 8: |
|
case "end": |
|
return _context2.stop(); |
|
} |
|
}, _callee2); |
|
})); |
|
return function (_x2, _x3) { |
|
return _ref2.apply(this, arguments); |
|
}; |
|
}(); |
|
|
|
var HotKeys = function HotKeys() { |
|
var _this = this; |
|
this.recentChats = []; |
|
this.chatHistory = { |
|
loading: false, |
|
items: [], |
|
total: 0, |
|
limit: 0, |
|
offset: 0 |
|
}; |
|
this.fetchAllChatHistory = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { |
|
var limit, offset, total, chatHistoryResponse; |
|
return _regeneratorRuntime().wrap(function _callee$(_context) { |
|
while (1) switch (_context.prev = _context.next) { |
|
case 0: |
|
_this.chatHistory.loading = true; |
|
limit = 100; |
|
offset = 0; |
|
total = 0; |
|
case 4: |
|
_context.next = 6; |
|
return ChatGptAPI.fetchChatHistory(offset, limit); |
|
case 6: |
|
chatHistoryResponse = _context.sent; |
|
_this.chatHistory.items = _this.chatHistory.items.concat(chatHistoryResponse.items); |
|
total = chatHistoryResponse.total; |
|
offset += limit; |
|
case 10: |
|
if (_this.chatHistory.items.length < total) { |
|
_context.next = 4; |
|
break; |
|
} |
|
case 11: |
|
_this.mergeRecentChats(); |
|
_this.sortChatHistory(); |
|
console.log('chatHistory', _this.chatHistory); |
|
_this.chatHistory.loading = false; |
|
case 15: |
|
case "end": |
|
return _context.stop(); |
|
} |
|
}, _callee); |
|
})); |
|
this.mergeRecentChats = function () { |
|
// merge recentChats with chatHistory.items |
|
_this.chatHistory.items = _this.chatHistory.items.map(function (item) { |
|
var recentChat = _this.recentChats.find(function (chat) { |
|
return chat.id === item.id; |
|
}); |
|
if (recentChat) { |
|
return _extends({}, item, { |
|
last_read: recentChat.last_read |
|
}); |
|
} |
|
return item; |
|
}); |
|
}; |
|
this.sortChatHistory = function () { |
|
// sort chatHistory.items based on last_read timestamp (which might be null) |
|
_this.chatHistory.items = _this.chatHistory.items.sort(function (a, b) { |
|
const isNewChat = v => v === "New chat"; |
|
if (isNewChat(a.title) && !isNewChat(b.title)) { |
|
return 1; |
|
} |
|
if (isNewChat(b.title) && !isNewChat(a.title)) { |
|
return -1; |
|
} |
|
var aDate = new Date(a.last_read || a.create_time); |
|
var bDate = new Date(b.last_read || b.create_time); |
|
return bDate.getTime() - aDate.getTime(); |
|
}); |
|
}; |
|
this.updateRecentChats = function (id) { |
|
var recentChat = _this.recentChats.find(function (chat) { |
|
return chat.id === id; |
|
}); |
|
if (recentChat) { |
|
recentChat.last_read = new Date().toISOString(); |
|
} else { |
|
_this.recentChats.push({ |
|
id: id, |
|
last_read: new Date().toISOString() |
|
}); |
|
} |
|
localStorage.setItem('recentChats', JSON.stringify(_this.recentChats)); |
|
_this.mergeRecentChats(); |
|
_this.sortChatHistory(); |
|
// update the ninja-keys data |
|
var ninja = document.querySelector("ninja-keys"); |
|
_this.getHotKeys().then(function (data) { |
|
console.log('updateRecentChats', data); |
|
ninja.data = data; |
|
}); |
|
}; |
|
this.handleChatClick = /*#__PURE__*/function () { |
|
var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(id) { |
|
var url; |
|
return _regeneratorRuntime().wrap(function _callee2$(_context2) { |
|
while (1) switch (_context2.prev = _context2.next) { |
|
case 0: |
|
_this.updateRecentChats(id); |
|
// // fetch the chat |
|
// const chat = await ChatGptAPI.fetchChatById(item.id); |
|
// const messages = Object.values(chat.mapping); |
|
// const ninja = document.querySelector("ninja-keys") as any; |
|
// ninja.data = messages.filter((message) => message?.message?.content?.parts?.join("\n")).map((message) => { |
|
// const title = message?.message?.content?.parts?.join("\n"); |
|
// console.log({ message, title }); |
|
// return { |
|
// id: message.id, |
|
// title, |
|
// // title: JSON.stringify(message.message), |
|
// handler: () => { |
|
// const url = `/chat/${item.id}`; |
|
// document.location.href = url; |
|
// } |
|
// }; |
|
// }); |
|
// ninja.open(); |
|
// - open the chat in the same tab |
|
url = "/chat/" + id; |
|
document.location.href = url; |
|
case 3: |
|
case "end": |
|
return _context2.stop(); |
|
} |
|
}, _callee2); |
|
})); |
|
return function (_x) { |
|
return _ref2.apply(this, arguments); |
|
}; |
|
}(); |
|
this.getChatTitle = function (item) { |
|
return item.title + " | " + new Date(item.create_time).toLocaleString(); |
|
// .toLocaleString()} |
|
// `${ |
|
// item.last_read ? ' [recent]' : '' |
|
// // ? `read ${new Date(item.last_read).toLocaleString()}` |
|
// // : 'unread' |
|
// }`; |
|
}; |
|
|
|
this.getHotKeys = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() { |
|
var hotkeys; |
|
return _regeneratorRuntime().wrap(function _callee4$(_context4) { |
|
while (1) switch (_context4.prev = _context4.next) { |
|
case 0: |
|
hotkeys = _this.chatHistory.items.map(function (item) { |
|
return { |
|
id: item.id, |
|
title: _this.getChatTitle(item), |
|
// mdIcon: "home", |
|
handler: function () { |
|
var _handler = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() { |
|
return _regeneratorRuntime().wrap(function _callee3$(_context3) { |
|
while (1) switch (_context3.prev = _context3.next) { |
|
case 0: |
|
return _context3.abrupt("return", _this.handleChatClick(item.id)); |
|
case 1: |
|
case "end": |
|
return _context3.stop(); |
|
} |
|
}, _callee3); |
|
})); |
|
function handler() { |
|
return _handler.apply(this, arguments); |
|
} |
|
return handler; |
|
}() |
|
}; |
|
}); |
|
return _context4.abrupt("return", hotkeys); |
|
case 2: |
|
case "end": |
|
return _context4.stop(); |
|
} |
|
}, _callee4); |
|
})); |
|
console.log('HotKeys constructor'); |
|
this.recentChats = JSON.parse(localStorage.getItem('recentChats') || '[]'); |
|
this.fetchAllChatHistory().then(function () { |
|
var ninja = document.createElement("ninja-keys"); |
|
_this.getHotKeys().then(function (data) { |
|
alert("Command palette ready!"); |
|
ninja.data = data; |
|
document.body.appendChild(ninja); |
|
}); |
|
}); |
|
}; |
|
|
|
var appendScriptTag = /*#__PURE__*/function () { |
|
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { |
|
var script; |
|
return _regeneratorRuntime().wrap(function _callee$(_context) { |
|
while (1) switch (_context.prev = _context.next) { |
|
case 0: |
|
script = document.createElement('script'); |
|
script.src = 'https://unpkg.com/ninja-keys?module'; |
|
script.type = 'module'; |
|
document.head.appendChild(script); |
|
case 4: |
|
case "end": |
|
return _context.stop(); |
|
} |
|
}, _callee); |
|
})); |
|
return function appendScriptTag() { |
|
return _ref.apply(this, arguments); |
|
}; |
|
}(); |
|
var initCommandPalette = /*#__PURE__*/function () { |
|
var _ref2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() { |
|
return _regeneratorRuntime().wrap(function _callee2$(_context2) { |
|
while (1) switch (_context2.prev = _context2.next) { |
|
case 0: |
|
new HotKeys(); |
|
case 1: |
|
case "end": |
|
return _context2.stop(); |
|
} |
|
}, _callee2); |
|
})); |
|
return function initCommandPalette() { |
|
return _ref2.apply(this, arguments); |
|
}; |
|
}(); |
|
|
|
var main = /*#__PURE__*/function () { |
|
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { |
|
return _regeneratorRuntime().wrap(function _callee$(_context) { |
|
while (1) switch (_context.prev = _context.next) { |
|
case 0: |
|
_context.next = 2; |
|
return appendScriptTag(); |
|
case 2: |
|
_context.next = 4; |
|
return initCommandPalette(); |
|
case 4: |
|
case "end": |
|
return _context.stop(); |
|
} |
|
}, _callee); |
|
})); |
|
return function main() { |
|
return _ref.apply(this, arguments); |
|
}; |
|
}(); |
|
document.addEventListener("DOMContentLoaded", main); |
|
// main(); |
|
//# sourceMappingURL=chat-gpt-cmd-palette.esm.js.map |
