You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1845 lines
64 KiB
1845 lines
64 KiB
/*
|
|
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
|
|
if you want to view the source, please visit the github repository of this plugin
|
|
*/
|
|
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
|
|
var __objRest = (source, exclude) => {
|
|
var target = {};
|
|
for (var prop in source)
|
|
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
|
|
target[prop] = source[prop];
|
|
if (source != null && __getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(source)) {
|
|
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
|
|
target[prop] = source[prop];
|
|
}
|
|
return target;
|
|
};
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
__markAsModule(target);
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __reExport = (target, module2, desc) => {
|
|
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
|
|
for (let key of __getOwnPropNames(module2))
|
|
if (!__hasOwnProp.call(target, key) && key !== "default")
|
|
__defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
|
|
}
|
|
return target;
|
|
};
|
|
var __toModule = (module2) => {
|
|
return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
|
|
};
|
|
var __async = (__this, __arguments, generator) => {
|
|
return new Promise((resolve, reject) => {
|
|
var fulfilled = (value) => {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var rejected = (value) => {
|
|
try {
|
|
step(generator.throw(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
|
step((generator = generator.apply(__this, __arguments)).next());
|
|
});
|
|
};
|
|
|
|
// node_modules/before-after-hook/lib/register.js
|
|
var require_register = __commonJS({
|
|
"node_modules/before-after-hook/lib/register.js"(exports, module2) {
|
|
module2.exports = register;
|
|
function register(state, name, method, options) {
|
|
if (typeof method !== "function") {
|
|
throw new Error("method for before hook must be a function");
|
|
}
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
if (Array.isArray(name)) {
|
|
return name.reverse().reduce(function(callback, name2) {
|
|
return register.bind(null, state, name2, callback, options);
|
|
}, method)();
|
|
}
|
|
return Promise.resolve().then(function() {
|
|
if (!state.registry[name]) {
|
|
return method(options);
|
|
}
|
|
return state.registry[name].reduce(function(method2, registered) {
|
|
return registered.hook.bind(null, method2, options);
|
|
}, method)();
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/before-after-hook/lib/add.js
|
|
var require_add = __commonJS({
|
|
"node_modules/before-after-hook/lib/add.js"(exports, module2) {
|
|
module2.exports = addHook;
|
|
function addHook(state, kind, name, hook2) {
|
|
var orig = hook2;
|
|
if (!state.registry[name]) {
|
|
state.registry[name] = [];
|
|
}
|
|
if (kind === "before") {
|
|
hook2 = function(method, options) {
|
|
return Promise.resolve().then(orig.bind(null, options)).then(method.bind(null, options));
|
|
};
|
|
}
|
|
if (kind === "after") {
|
|
hook2 = function(method, options) {
|
|
var result;
|
|
return Promise.resolve().then(method.bind(null, options)).then(function(result_) {
|
|
result = result_;
|
|
return orig(result, options);
|
|
}).then(function() {
|
|
return result;
|
|
});
|
|
};
|
|
}
|
|
if (kind === "error") {
|
|
hook2 = function(method, options) {
|
|
return Promise.resolve().then(method.bind(null, options)).catch(function(error) {
|
|
return orig(error, options);
|
|
});
|
|
};
|
|
}
|
|
state.registry[name].push({
|
|
hook: hook2,
|
|
orig
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/before-after-hook/lib/remove.js
|
|
var require_remove = __commonJS({
|
|
"node_modules/before-after-hook/lib/remove.js"(exports, module2) {
|
|
module2.exports = removeHook;
|
|
function removeHook(state, name, method) {
|
|
if (!state.registry[name]) {
|
|
return;
|
|
}
|
|
var index = state.registry[name].map(function(registered) {
|
|
return registered.orig;
|
|
}).indexOf(method);
|
|
if (index === -1) {
|
|
return;
|
|
}
|
|
state.registry[name].splice(index, 1);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/before-after-hook/index.js
|
|
var require_before_after_hook = __commonJS({
|
|
"node_modules/before-after-hook/index.js"(exports, module2) {
|
|
var register = require_register();
|
|
var addHook = require_add();
|
|
var removeHook = require_remove();
|
|
var bind = Function.bind;
|
|
var bindable = bind.bind(bind);
|
|
function bindApi(hook2, state, name) {
|
|
var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]);
|
|
hook2.api = { remove: removeHookRef };
|
|
hook2.remove = removeHookRef;
|
|
["before", "error", "after", "wrap"].forEach(function(kind) {
|
|
var args = name ? [state, kind, name] : [state, kind];
|
|
hook2[kind] = hook2.api[kind] = bindable(addHook, null).apply(null, args);
|
|
});
|
|
}
|
|
function HookSingular() {
|
|
var singularHookName = "h";
|
|
var singularHookState = {
|
|
registry: {}
|
|
};
|
|
var singularHook = register.bind(null, singularHookState, singularHookName);
|
|
bindApi(singularHook, singularHookState, singularHookName);
|
|
return singularHook;
|
|
}
|
|
function HookCollection() {
|
|
var state = {
|
|
registry: {}
|
|
};
|
|
var hook2 = register.bind(null, state);
|
|
bindApi(hook2, state);
|
|
return hook2;
|
|
}
|
|
var collectionHookDeprecationMessageDisplayed = false;
|
|
function Hook() {
|
|
if (!collectionHookDeprecationMessageDisplayed) {
|
|
console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4');
|
|
collectionHookDeprecationMessageDisplayed = true;
|
|
}
|
|
return HookCollection();
|
|
}
|
|
Hook.Singular = HookSingular.bind();
|
|
Hook.Collection = HookCollection.bind();
|
|
module2.exports = Hook;
|
|
module2.exports.Hook = Hook;
|
|
module2.exports.Singular = Hook.Singular;
|
|
module2.exports.Collection = Hook.Collection;
|
|
}
|
|
});
|
|
|
|
// node_modules/node-fetch/browser.js
|
|
var require_browser = __commonJS({
|
|
"node_modules/node-fetch/browser.js"(exports, module2) {
|
|
"use strict";
|
|
var getGlobal = function() {
|
|
if (typeof self !== "undefined") {
|
|
return self;
|
|
}
|
|
if (typeof window !== "undefined") {
|
|
return window;
|
|
}
|
|
if (typeof global !== "undefined") {
|
|
return global;
|
|
}
|
|
throw new Error("unable to locate global object");
|
|
};
|
|
var global = getGlobal();
|
|
module2.exports = exports = global.fetch;
|
|
if (global.fetch) {
|
|
exports.default = global.fetch.bind(global);
|
|
}
|
|
exports.Headers = global.Headers;
|
|
exports.Request = global.Request;
|
|
exports.Response = global.Response;
|
|
}
|
|
});
|
|
|
|
// node_modules/wrappy/wrappy.js
|
|
var require_wrappy = __commonJS({
|
|
"node_modules/wrappy/wrappy.js"(exports, module2) {
|
|
module2.exports = wrappy;
|
|
function wrappy(fn, cb) {
|
|
if (fn && cb)
|
|
return wrappy(fn)(cb);
|
|
if (typeof fn !== "function")
|
|
throw new TypeError("need wrapper function");
|
|
Object.keys(fn).forEach(function(k) {
|
|
wrapper[k] = fn[k];
|
|
});
|
|
return wrapper;
|
|
function wrapper() {
|
|
var args = new Array(arguments.length);
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
var ret = fn.apply(this, args);
|
|
var cb2 = args[args.length - 1];
|
|
if (typeof ret === "function" && ret !== cb2) {
|
|
Object.keys(cb2).forEach(function(k) {
|
|
ret[k] = cb2[k];
|
|
});
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/once/once.js
|
|
var require_once = __commonJS({
|
|
"node_modules/once/once.js"(exports, module2) {
|
|
var wrappy = require_wrappy();
|
|
module2.exports = wrappy(once2);
|
|
module2.exports.strict = wrappy(onceStrict);
|
|
once2.proto = once2(function() {
|
|
Object.defineProperty(Function.prototype, "once", {
|
|
value: function() {
|
|
return once2(this);
|
|
},
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Function.prototype, "onceStrict", {
|
|
value: function() {
|
|
return onceStrict(this);
|
|
},
|
|
configurable: true
|
|
});
|
|
});
|
|
function once2(fn) {
|
|
var f = function() {
|
|
if (f.called)
|
|
return f.value;
|
|
f.called = true;
|
|
return f.value = fn.apply(this, arguments);
|
|
};
|
|
f.called = false;
|
|
return f;
|
|
}
|
|
function onceStrict(fn) {
|
|
var f = function() {
|
|
if (f.called)
|
|
throw new Error(f.onceError);
|
|
f.called = true;
|
|
return f.value = fn.apply(this, arguments);
|
|
};
|
|
var name = fn.name || "Function wrapped with `once`";
|
|
f.onceError = name + " shouldn't be called more than once";
|
|
f.called = false;
|
|
return f;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Snippet-downloader/main.ts
|
|
__export(exports, {
|
|
default: () => snippetDownloader
|
|
});
|
|
var import_obsidian8 = __toModule(require("obsidian"));
|
|
|
|
// Snippet-downloader/settings.ts
|
|
var import_obsidian7 = __toModule(require("obsidian"));
|
|
|
|
// Snippet-downloader/removeSnippet.ts
|
|
var import_obsidian = __toModule(require("obsidian"));
|
|
|
|
// Snippet-downloader/utils.ts
|
|
function searchExcluded(excludedSnippet, name) {
|
|
if (excludedSnippet.length < 1) {
|
|
return false;
|
|
}
|
|
const excluded = excludedSnippet.split(",").map((e) => {
|
|
return e.trim();
|
|
}).filter((x) => x.length > 0);
|
|
for (const excl of excluded) {
|
|
if (excl === name.replace(".css", "").trim()) {
|
|
return true;
|
|
}
|
|
if (name.match(new RegExp(excl))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function basename(path) {
|
|
return path.split("/").reverse()[0];
|
|
}
|
|
|
|
// Snippet-downloader/removeSnippet.ts
|
|
function removeErrorSnippet(repoPath, errorSnippet, snippetList) {
|
|
const snippet = snippetList.find((snippet2) => snippet2.repo === repoPath);
|
|
let errorSnippetList = errorSnippet.split(", ");
|
|
for (const snippetContents of snippet.snippetsContents) {
|
|
errorSnippetList = errorSnippetList.filter((v) => v != snippetContents.name.replace(".css", "").trim());
|
|
}
|
|
console.log(errorSnippetList);
|
|
return errorSnippetList.join(", ");
|
|
}
|
|
function removeSnippet(repoPath, snippetList, errorSnippet) {
|
|
if (snippetList.some((snippet) => snippet.repo === repoPath)) {
|
|
errorSnippet = removeErrorSnippet(repoPath, errorSnippet, snippetList);
|
|
snippetList.splice(snippetList.findIndex((snippet) => snippet.repo === repoPath), 1);
|
|
new import_obsidian.Notice("Repository successfully removed \u{1F389}");
|
|
return [snippetList, errorSnippet];
|
|
}
|
|
new import_obsidian.Notice("Error : this repo is not in the list \u{1F63F}");
|
|
return [snippetList, errorSnippet];
|
|
}
|
|
function removeSnippetFromExcluded(repoPath, snippetList, errorSnippet, excludedSnippet) {
|
|
const repo = snippetList.find((snippet) => snippet.repo === repoPath);
|
|
repo.snippetsContents = repo.snippetsContents.filter((snippet) => !searchExcluded(excludedSnippet, snippet.name) && !searchExcluded(errorSnippet, snippet.name));
|
|
return snippetList;
|
|
}
|
|
|
|
// Snippet-downloader/modals/simpleCommands.ts
|
|
var import_obsidian2 = __toModule(require("obsidian"));
|
|
var SnippetDownloaderModals = class extends import_obsidian2.Modal {
|
|
constructor(app, onSubmit) {
|
|
super(app);
|
|
this.onSubmit = onSubmit;
|
|
}
|
|
onOpen() {
|
|
const { contentEl } = this;
|
|
contentEl.createEl("h1", { text: "Repo Links" });
|
|
new import_obsidian2.Setting(contentEl).setName("Repo Link").addText((text) => {
|
|
text.onChange((value) => {
|
|
this.result = value;
|
|
});
|
|
});
|
|
new import_obsidian2.Setting(contentEl).addButton((btn) => {
|
|
btn.setButtonText("Submit").setCta().onClick(() => {
|
|
this.close();
|
|
this.onSubmit(this.result);
|
|
});
|
|
});
|
|
}
|
|
onClose() {
|
|
const { contentEl } = this;
|
|
contentEl.empty();
|
|
}
|
|
};
|
|
|
|
// Snippet-downloader/addSnippets.ts
|
|
var import_obsidian4 = __toModule(require("obsidian"));
|
|
|
|
// node_modules/universal-user-agent/dist-web/index.js
|
|
function getUserAgent() {
|
|
if (typeof navigator === "object" && "userAgent" in navigator) {
|
|
return navigator.userAgent;
|
|
}
|
|
if (typeof process === "object" && "version" in process) {
|
|
return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
|
|
}
|
|
return "<environment undetectable>";
|
|
}
|
|
|
|
// node_modules/@octokit/core/dist-web/index.js
|
|
var import_before_after_hook = __toModule(require_before_after_hook());
|
|
|
|
// node_modules/is-plain-object/dist/is-plain-object.mjs
|
|
function isObject(o) {
|
|
return Object.prototype.toString.call(o) === "[object Object]";
|
|
}
|
|
function isPlainObject(o) {
|
|
var ctor, prot;
|
|
if (isObject(o) === false)
|
|
return false;
|
|
ctor = o.constructor;
|
|
if (ctor === void 0)
|
|
return true;
|
|
prot = ctor.prototype;
|
|
if (isObject(prot) === false)
|
|
return false;
|
|
if (prot.hasOwnProperty("isPrototypeOf") === false) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// node_modules/@octokit/endpoint/dist-web/index.js
|
|
function lowercaseKeys(object) {
|
|
if (!object) {
|
|
return {};
|
|
}
|
|
return Object.keys(object).reduce((newObj, key) => {
|
|
newObj[key.toLowerCase()] = object[key];
|
|
return newObj;
|
|
}, {});
|
|
}
|
|
function mergeDeep(defaults, options) {
|
|
const result = Object.assign({}, defaults);
|
|
Object.keys(options).forEach((key) => {
|
|
if (isPlainObject(options[key])) {
|
|
if (!(key in defaults))
|
|
Object.assign(result, { [key]: options[key] });
|
|
else
|
|
result[key] = mergeDeep(defaults[key], options[key]);
|
|
} else {
|
|
Object.assign(result, { [key]: options[key] });
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function removeUndefinedProperties(obj) {
|
|
for (const key in obj) {
|
|
if (obj[key] === void 0) {
|
|
delete obj[key];
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
function merge(defaults, route, options) {
|
|
if (typeof route === "string") {
|
|
let [method, url] = route.split(" ");
|
|
options = Object.assign(url ? { method, url } : { url: method }, options);
|
|
} else {
|
|
options = Object.assign({}, route);
|
|
}
|
|
options.headers = lowercaseKeys(options.headers);
|
|
removeUndefinedProperties(options);
|
|
removeUndefinedProperties(options.headers);
|
|
const mergedOptions = mergeDeep(defaults || {}, options);
|
|
if (defaults && defaults.mediaType.previews.length) {
|
|
mergedOptions.mediaType.previews = defaults.mediaType.previews.filter((preview) => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
|
|
}
|
|
mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map((preview) => preview.replace(/-preview/, ""));
|
|
return mergedOptions;
|
|
}
|
|
function addQueryParameters(url, parameters) {
|
|
const separator = /\?/.test(url) ? "&" : "?";
|
|
const names = Object.keys(parameters);
|
|
if (names.length === 0) {
|
|
return url;
|
|
}
|
|
return url + separator + names.map((name) => {
|
|
if (name === "q") {
|
|
return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
|
|
}
|
|
return `${name}=${encodeURIComponent(parameters[name])}`;
|
|
}).join("&");
|
|
}
|
|
var urlVariableRegex = /\{[^}]+\}/g;
|
|
function removeNonChars(variableName) {
|
|
return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
|
|
}
|
|
function extractUrlVariableNames(url) {
|
|
const matches = url.match(urlVariableRegex);
|
|
if (!matches) {
|
|
return [];
|
|
}
|
|
return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
|
|
}
|
|
function omit(object, keysToOmit) {
|
|
return Object.keys(object).filter((option) => !keysToOmit.includes(option)).reduce((obj, key) => {
|
|
obj[key] = object[key];
|
|
return obj;
|
|
}, {});
|
|
}
|
|
function encodeReserved(str) {
|
|
return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
|
|
if (!/%[0-9A-Fa-f]/.test(part)) {
|
|
part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
|
|
}
|
|
return part;
|
|
}).join("");
|
|
}
|
|
function encodeUnreserved(str) {
|
|
return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
|
|
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
|
|
});
|
|
}
|
|
function encodeValue(operator, value, key) {
|
|
value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
|
|
if (key) {
|
|
return encodeUnreserved(key) + "=" + value;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
function isDefined(value) {
|
|
return value !== void 0 && value !== null;
|
|
}
|
|
function isKeyOperator(operator) {
|
|
return operator === ";" || operator === "&" || operator === "?";
|
|
}
|
|
function getValues(context, operator, key, modifier) {
|
|
var value = context[key], result = [];
|
|
if (isDefined(value) && value !== "") {
|
|
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
|
|
value = value.toString();
|
|
if (modifier && modifier !== "*") {
|
|
value = value.substring(0, parseInt(modifier, 10));
|
|
}
|
|
result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
|
|
} else {
|
|
if (modifier === "*") {
|
|
if (Array.isArray(value)) {
|
|
value.filter(isDefined).forEach(function(value2) {
|
|
result.push(encodeValue(operator, value2, isKeyOperator(operator) ? key : ""));
|
|
});
|
|
} else {
|
|
Object.keys(value).forEach(function(k) {
|
|
if (isDefined(value[k])) {
|
|
result.push(encodeValue(operator, value[k], k));
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
const tmp = [];
|
|
if (Array.isArray(value)) {
|
|
value.filter(isDefined).forEach(function(value2) {
|
|
tmp.push(encodeValue(operator, value2));
|
|
});
|
|
} else {
|
|
Object.keys(value).forEach(function(k) {
|
|
if (isDefined(value[k])) {
|
|
tmp.push(encodeUnreserved(k));
|
|
tmp.push(encodeValue(operator, value[k].toString()));
|
|
}
|
|
});
|
|
}
|
|
if (isKeyOperator(operator)) {
|
|
result.push(encodeUnreserved(key) + "=" + tmp.join(","));
|
|
} else if (tmp.length !== 0) {
|
|
result.push(tmp.join(","));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (operator === ";") {
|
|
if (isDefined(value)) {
|
|
result.push(encodeUnreserved(key));
|
|
}
|
|
} else if (value === "" && (operator === "&" || operator === "?")) {
|
|
result.push(encodeUnreserved(key) + "=");
|
|
} else if (value === "") {
|
|
result.push("");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function parseUrl(template) {
|
|
return {
|
|
expand: expand.bind(null, template)
|
|
};
|
|
}
|
|
function expand(template, context) {
|
|
var operators = ["+", "#", ".", "/", ";", "?", "&"];
|
|
return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression, literal) {
|
|
if (expression) {
|
|
let operator = "";
|
|
const values = [];
|
|
if (operators.indexOf(expression.charAt(0)) !== -1) {
|
|
operator = expression.charAt(0);
|
|
expression = expression.substr(1);
|
|
}
|
|
expression.split(/,/g).forEach(function(variable) {
|
|
var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
|
|
values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
|
|
});
|
|
if (operator && operator !== "+") {
|
|
var separator = ",";
|
|
if (operator === "?") {
|
|
separator = "&";
|
|
} else if (operator !== "#") {
|
|
separator = operator;
|
|
}
|
|
return (values.length !== 0 ? operator : "") + values.join(separator);
|
|
} else {
|
|
return values.join(",");
|
|
}
|
|
} else {
|
|
return encodeReserved(literal);
|
|
}
|
|
});
|
|
}
|
|
function parse(options) {
|
|
let method = options.method.toUpperCase();
|
|
let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
|
|
let headers = Object.assign({}, options.headers);
|
|
let body;
|
|
let parameters = omit(options, [
|
|
"method",
|
|
"baseUrl",
|
|
"url",
|
|
"headers",
|
|
"request",
|
|
"mediaType"
|
|
]);
|
|
const urlVariableNames = extractUrlVariableNames(url);
|
|
url = parseUrl(url).expand(parameters);
|
|
if (!/^http/.test(url)) {
|
|
url = options.baseUrl + url;
|
|
}
|
|
const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl");
|
|
const remainingParameters = omit(parameters, omittedParameters);
|
|
const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
|
|
if (!isBinaryRequest) {
|
|
if (options.mediaType.format) {
|
|
headers.accept = headers.accept.split(/,/).map((preview) => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
|
|
}
|
|
if (options.mediaType.previews.length) {
|
|
const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
|
|
headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => {
|
|
const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
|
|
return `application/vnd.github.${preview}-preview${format}`;
|
|
}).join(",");
|
|
}
|
|
}
|
|
if (["GET", "HEAD"].includes(method)) {
|
|
url = addQueryParameters(url, remainingParameters);
|
|
} else {
|
|
if ("data" in remainingParameters) {
|
|
body = remainingParameters.data;
|
|
} else {
|
|
if (Object.keys(remainingParameters).length) {
|
|
body = remainingParameters;
|
|
} else {
|
|
headers["content-length"] = 0;
|
|
}
|
|
}
|
|
}
|
|
if (!headers["content-type"] && typeof body !== "undefined") {
|
|
headers["content-type"] = "application/json; charset=utf-8";
|
|
}
|
|
if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
|
|
body = "";
|
|
}
|
|
return Object.assign({ method, url, headers }, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null);
|
|
}
|
|
function endpointWithDefaults(defaults, route, options) {
|
|
return parse(merge(defaults, route, options));
|
|
}
|
|
function withDefaults(oldDefaults, newDefaults) {
|
|
const DEFAULTS2 = merge(oldDefaults, newDefaults);
|
|
const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
|
|
return Object.assign(endpoint2, {
|
|
DEFAULTS: DEFAULTS2,
|
|
defaults: withDefaults.bind(null, DEFAULTS2),
|
|
merge: merge.bind(null, DEFAULTS2),
|
|
parse
|
|
});
|
|
}
|
|
var VERSION = "6.0.12";
|
|
var userAgent = `octokit-endpoint.js/${VERSION} ${getUserAgent()}`;
|
|
var DEFAULTS = {
|
|
method: "GET",
|
|
baseUrl: "https://api.github.com",
|
|
headers: {
|
|
accept: "application/vnd.github.v3+json",
|
|
"user-agent": userAgent
|
|
},
|
|
mediaType: {
|
|
format: "",
|
|
previews: []
|
|
}
|
|
};
|
|
var endpoint = withDefaults(null, DEFAULTS);
|
|
|
|
// node_modules/@octokit/request/dist-web/index.js
|
|
var import_node_fetch = __toModule(require_browser());
|
|
|
|
// node_modules/deprecation/dist-web/index.js
|
|
var Deprecation = class extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
this.name = "Deprecation";
|
|
}
|
|
};
|
|
|
|
// node_modules/@octokit/request-error/dist-web/index.js
|
|
var import_once = __toModule(require_once());
|
|
var logOnceCode = (0, import_once.default)((deprecation) => console.warn(deprecation));
|
|
var logOnceHeaders = (0, import_once.default)((deprecation) => console.warn(deprecation));
|
|
var RequestError = class extends Error {
|
|
constructor(message, statusCode, options) {
|
|
super(message);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
this.name = "HttpError";
|
|
this.status = statusCode;
|
|
let headers;
|
|
if ("headers" in options && typeof options.headers !== "undefined") {
|
|
headers = options.headers;
|
|
}
|
|
if ("response" in options) {
|
|
this.response = options.response;
|
|
headers = options.response.headers;
|
|
}
|
|
const requestCopy = Object.assign({}, options.request);
|
|
if (options.request.headers.authorization) {
|
|
requestCopy.headers = Object.assign({}, options.request.headers, {
|
|
authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]")
|
|
});
|
|
}
|
|
requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
|
|
this.request = requestCopy;
|
|
Object.defineProperty(this, "code", {
|
|
get() {
|
|
logOnceCode(new Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
|
|
return statusCode;
|
|
}
|
|
});
|
|
Object.defineProperty(this, "headers", {
|
|
get() {
|
|
logOnceHeaders(new Deprecation("[@octokit/request-error] `error.headers` is deprecated, use `error.response.headers`."));
|
|
return headers || {};
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/@octokit/request/dist-web/index.js
|
|
var VERSION2 = "5.6.3";
|
|
function getBufferResponse(response) {
|
|
return response.arrayBuffer();
|
|
}
|
|
function fetchWrapper(requestOptions) {
|
|
const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console;
|
|
if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) {
|
|
requestOptions.body = JSON.stringify(requestOptions.body);
|
|
}
|
|
let headers = {};
|
|
let status;
|
|
let url;
|
|
const fetch = requestOptions.request && requestOptions.request.fetch || import_node_fetch.default;
|
|
return fetch(requestOptions.url, Object.assign({
|
|
method: requestOptions.method,
|
|
body: requestOptions.body,
|
|
headers: requestOptions.headers,
|
|
redirect: requestOptions.redirect
|
|
}, requestOptions.request)).then((response) => __async(this, null, function* () {
|
|
url = response.url;
|
|
status = response.status;
|
|
for (const keyAndValue of response.headers) {
|
|
headers[keyAndValue[0]] = keyAndValue[1];
|
|
}
|
|
if ("deprecation" in headers) {
|
|
const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/);
|
|
const deprecationLink = matches && matches.pop();
|
|
log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`);
|
|
}
|
|
if (status === 204 || status === 205) {
|
|
return;
|
|
}
|
|
if (requestOptions.method === "HEAD") {
|
|
if (status < 400) {
|
|
return;
|
|
}
|
|
throw new RequestError(response.statusText, status, {
|
|
response: {
|
|
url,
|
|
status,
|
|
headers,
|
|
data: void 0
|
|
},
|
|
request: requestOptions
|
|
});
|
|
}
|
|
if (status === 304) {
|
|
throw new RequestError("Not modified", status, {
|
|
response: {
|
|
url,
|
|
status,
|
|
headers,
|
|
data: yield getResponseData(response)
|
|
},
|
|
request: requestOptions
|
|
});
|
|
}
|
|
if (status >= 400) {
|
|
const data = yield getResponseData(response);
|
|
const error = new RequestError(toErrorMessage(data), status, {
|
|
response: {
|
|
url,
|
|
status,
|
|
headers,
|
|
data
|
|
},
|
|
request: requestOptions
|
|
});
|
|
throw error;
|
|
}
|
|
return getResponseData(response);
|
|
})).then((data) => {
|
|
return {
|
|
status,
|
|
url,
|
|
headers,
|
|
data
|
|
};
|
|
}).catch((error) => {
|
|
if (error instanceof RequestError)
|
|
throw error;
|
|
throw new RequestError(error.message, 500, {
|
|
request: requestOptions
|
|
});
|
|
});
|
|
}
|
|
function getResponseData(response) {
|
|
return __async(this, null, function* () {
|
|
const contentType = response.headers.get("content-type");
|
|
if (/application\/json/.test(contentType)) {
|
|
return response.json();
|
|
}
|
|
if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
|
|
return response.text();
|
|
}
|
|
return getBufferResponse(response);
|
|
});
|
|
}
|
|
function toErrorMessage(data) {
|
|
if (typeof data === "string")
|
|
return data;
|
|
if ("message" in data) {
|
|
if (Array.isArray(data.errors)) {
|
|
return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`;
|
|
}
|
|
return data.message;
|
|
}
|
|
return `Unknown error: ${JSON.stringify(data)}`;
|
|
}
|
|
function withDefaults2(oldEndpoint, newDefaults) {
|
|
const endpoint2 = oldEndpoint.defaults(newDefaults);
|
|
const newApi = function(route, parameters) {
|
|
const endpointOptions = endpoint2.merge(route, parameters);
|
|
if (!endpointOptions.request || !endpointOptions.request.hook) {
|
|
return fetchWrapper(endpoint2.parse(endpointOptions));
|
|
}
|
|
const request3 = (route2, parameters2) => {
|
|
return fetchWrapper(endpoint2.parse(endpoint2.merge(route2, parameters2)));
|
|
};
|
|
Object.assign(request3, {
|
|
endpoint: endpoint2,
|
|
defaults: withDefaults2.bind(null, endpoint2)
|
|
});
|
|
return endpointOptions.request.hook(request3, endpointOptions);
|
|
};
|
|
return Object.assign(newApi, {
|
|
endpoint: endpoint2,
|
|
defaults: withDefaults2.bind(null, endpoint2)
|
|
});
|
|
}
|
|
var request = withDefaults2(endpoint, {
|
|
headers: {
|
|
"user-agent": `octokit-request.js/${VERSION2} ${getUserAgent()}`
|
|
}
|
|
});
|
|
|
|
// node_modules/@octokit/graphql/dist-web/index.js
|
|
var VERSION3 = "4.8.0";
|
|
function _buildMessageForResponseErrors(data) {
|
|
return `Request failed due to following response errors:
|
|
` + data.errors.map((e) => ` - ${e.message}`).join("\n");
|
|
}
|
|
var GraphqlResponseError = class extends Error {
|
|
constructor(request3, headers, response) {
|
|
super(_buildMessageForResponseErrors(response));
|
|
this.request = request3;
|
|
this.headers = headers;
|
|
this.response = response;
|
|
this.name = "GraphqlResponseError";
|
|
this.errors = response.errors;
|
|
this.data = response.data;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
}
|
|
};
|
|
var NON_VARIABLE_OPTIONS = [
|
|
"method",
|
|
"baseUrl",
|
|
"url",
|
|
"headers",
|
|
"request",
|
|
"query",
|
|
"mediaType"
|
|
];
|
|
var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
|
|
var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
|
|
function graphql(request3, query, options) {
|
|
if (options) {
|
|
if (typeof query === "string" && "query" in options) {
|
|
return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
|
|
}
|
|
for (const key in options) {
|
|
if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key))
|
|
continue;
|
|
return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`));
|
|
}
|
|
}
|
|
const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
|
|
const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
|
|
if (NON_VARIABLE_OPTIONS.includes(key)) {
|
|
result[key] = parsedOptions[key];
|
|
return result;
|
|
}
|
|
if (!result.variables) {
|
|
result.variables = {};
|
|
}
|
|
result.variables[key] = parsedOptions[key];
|
|
return result;
|
|
}, {});
|
|
const baseUrl = parsedOptions.baseUrl || request3.endpoint.DEFAULTS.baseUrl;
|
|
if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
|
|
requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
|
|
}
|
|
return request3(requestOptions).then((response) => {
|
|
if (response.data.errors) {
|
|
const headers = {};
|
|
for (const key of Object.keys(response.headers)) {
|
|
headers[key] = response.headers[key];
|
|
}
|
|
throw new GraphqlResponseError(requestOptions, headers, response.data);
|
|
}
|
|
return response.data.data;
|
|
});
|
|
}
|
|
function withDefaults3(request$1, newDefaults) {
|
|
const newRequest = request$1.defaults(newDefaults);
|
|
const newApi = (query, options) => {
|
|
return graphql(newRequest, query, options);
|
|
};
|
|
return Object.assign(newApi, {
|
|
defaults: withDefaults3.bind(null, newRequest),
|
|
endpoint: request.endpoint
|
|
});
|
|
}
|
|
var graphql$1 = withDefaults3(request, {
|
|
headers: {
|
|
"user-agent": `octokit-graphql.js/${VERSION3} ${getUserAgent()}`
|
|
},
|
|
method: "POST",
|
|
url: "/graphql"
|
|
});
|
|
function withCustomRequest(customRequest) {
|
|
return withDefaults3(customRequest, {
|
|
method: "POST",
|
|
url: "/graphql"
|
|
});
|
|
}
|
|
|
|
// node_modules/@octokit/auth-token/dist-web/index.js
|
|
var REGEX_IS_INSTALLATION_LEGACY = /^v1\./;
|
|
var REGEX_IS_INSTALLATION = /^ghs_/;
|
|
var REGEX_IS_USER_TO_SERVER = /^ghu_/;
|
|
function auth(token) {
|
|
return __async(this, null, function* () {
|
|
const isApp = token.split(/\./).length === 3;
|
|
const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token);
|
|
const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token);
|
|
const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth";
|
|
return {
|
|
type: "token",
|
|
token,
|
|
tokenType
|
|
};
|
|
});
|
|
}
|
|
function withAuthorizationPrefix(token) {
|
|
if (token.split(/\./).length === 3) {
|
|
return `bearer ${token}`;
|
|
}
|
|
return `token ${token}`;
|
|
}
|
|
function hook(token, request3, route, parameters) {
|
|
return __async(this, null, function* () {
|
|
const endpoint2 = request3.endpoint.merge(route, parameters);
|
|
endpoint2.headers.authorization = withAuthorizationPrefix(token);
|
|
return request3(endpoint2);
|
|
});
|
|
}
|
|
var createTokenAuth = function createTokenAuth2(token) {
|
|
if (!token) {
|
|
throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
|
|
}
|
|
if (typeof token !== "string") {
|
|
throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
|
|
}
|
|
token = token.replace(/^(token|bearer) +/i, "");
|
|
return Object.assign(auth.bind(null, token), {
|
|
hook: hook.bind(null, token)
|
|
});
|
|
};
|
|
|
|
// node_modules/@octokit/core/dist-web/index.js
|
|
var VERSION4 = "3.6.0";
|
|
var Octokit = class {
|
|
constructor(options = {}) {
|
|
const hook2 = new import_before_after_hook.Collection();
|
|
const requestDefaults = {
|
|
baseUrl: request.endpoint.DEFAULTS.baseUrl,
|
|
headers: {},
|
|
request: Object.assign({}, options.request, {
|
|
hook: hook2.bind(null, "request")
|
|
}),
|
|
mediaType: {
|
|
previews: [],
|
|
format: ""
|
|
}
|
|
};
|
|
requestDefaults.headers["user-agent"] = [
|
|
options.userAgent,
|
|
`octokit-core.js/${VERSION4} ${getUserAgent()}`
|
|
].filter(Boolean).join(" ");
|
|
if (options.baseUrl) {
|
|
requestDefaults.baseUrl = options.baseUrl;
|
|
}
|
|
if (options.previews) {
|
|
requestDefaults.mediaType.previews = options.previews;
|
|
}
|
|
if (options.timeZone) {
|
|
requestDefaults.headers["time-zone"] = options.timeZone;
|
|
}
|
|
this.request = request.defaults(requestDefaults);
|
|
this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
|
|
this.log = Object.assign({
|
|
debug: () => {
|
|
},
|
|
info: () => {
|
|
},
|
|
warn: console.warn.bind(console),
|
|
error: console.error.bind(console)
|
|
}, options.log);
|
|
this.hook = hook2;
|
|
if (!options.authStrategy) {
|
|
if (!options.auth) {
|
|
this.auth = () => __async(this, null, function* () {
|
|
return {
|
|
type: "unauthenticated"
|
|
};
|
|
});
|
|
} else {
|
|
const auth2 = createTokenAuth(options.auth);
|
|
hook2.wrap("request", auth2.hook);
|
|
this.auth = auth2;
|
|
}
|
|
} else {
|
|
const _a = options, { authStrategy } = _a, otherOptions = __objRest(_a, ["authStrategy"]);
|
|
const auth2 = authStrategy(Object.assign({
|
|
request: this.request,
|
|
log: this.log,
|
|
octokit: this,
|
|
octokitOptions: otherOptions
|
|
}, options.auth));
|
|
hook2.wrap("request", auth2.hook);
|
|
this.auth = auth2;
|
|
}
|
|
const classConstructor = this.constructor;
|
|
classConstructor.plugins.forEach((plugin) => {
|
|
Object.assign(this, plugin(this, options));
|
|
});
|
|
}
|
|
static defaults(defaults) {
|
|
const OctokitWithDefaults = class extends this {
|
|
constructor(...args) {
|
|
const options = args[0] || {};
|
|
if (typeof defaults === "function") {
|
|
super(defaults(options));
|
|
return;
|
|
}
|
|
super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? {
|
|
userAgent: `${options.userAgent} ${defaults.userAgent}`
|
|
} : null));
|
|
}
|
|
};
|
|
return OctokitWithDefaults;
|
|
}
|
|
static plugin(...newPlugins) {
|
|
var _a;
|
|
const currentPlugins = this.plugins;
|
|
const NewOctokit = (_a = class extends this {
|
|
}, _a.plugins = currentPlugins.concat(newPlugins.filter((plugin) => !currentPlugins.includes(plugin))), _a);
|
|
return NewOctokit;
|
|
}
|
|
};
|
|
Octokit.VERSION = VERSION4;
|
|
Octokit.plugins = [];
|
|
|
|
// node_modules/js-base64/base64.mjs
|
|
var version = "3.7.2";
|
|
var VERSION5 = version;
|
|
var _hasatob = typeof atob === "function";
|
|
var _hasbtoa = typeof btoa === "function";
|
|
var _hasBuffer = typeof Buffer === "function";
|
|
var _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0;
|
|
var _TE = typeof TextEncoder === "function" ? new TextEncoder() : void 0;
|
|
var b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
|
|
var b64chs = Array.prototype.slice.call(b64ch);
|
|
var b64tab = ((a) => {
|
|
let tab = {};
|
|
a.forEach((c, i) => tab[c] = i);
|
|
return tab;
|
|
})(b64chs);
|
|
var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
|
|
var _fromCC = String.fromCharCode.bind(String);
|
|
var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it, fn = (x) => x) => new Uint8Array(Array.prototype.slice.call(it, 0).map(fn));
|
|
var _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_");
|
|
var _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, "");
|
|
var btoaPolyfill = (bin) => {
|
|
let u32, c0, c1, c2, asc = "";
|
|
const pad = bin.length % 3;
|
|
for (let i = 0; i < bin.length; ) {
|
|
if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255)
|
|
throw new TypeError("invalid character found");
|
|
u32 = c0 << 16 | c1 << 8 | c2;
|
|
asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
|
|
}
|
|
return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
|
|
};
|
|
var _btoa = _hasbtoa ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill;
|
|
var _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => {
|
|
const maxargs = 4096;
|
|
let strs = [];
|
|
for (let i = 0, l = u8a.length; i < l; i += maxargs) {
|
|
strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
|
|
}
|
|
return _btoa(strs.join(""));
|
|
};
|
|
var fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
|
|
var cb_utob = (c) => {
|
|
if (c.length < 2) {
|
|
var cc = c.charCodeAt(0);
|
|
return cc < 128 ? c : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
|
|
} else {
|
|
var cc = 65536 + (c.charCodeAt(0) - 55296) * 1024 + (c.charCodeAt(1) - 56320);
|
|
return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
|
|
}
|
|
};
|
|
var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
|
|
var utob = (u) => u.replace(re_utob, cb_utob);
|
|
var _encode = _hasBuffer ? (s) => Buffer.from(s, "utf8").toString("base64") : _TE ? (s) => _fromUint8Array(_TE.encode(s)) : (s) => _btoa(utob(s));
|
|
var encode = (src, urlsafe = false) => urlsafe ? _mkUriSafe(_encode(src)) : _encode(src);
|
|
var encodeURI2 = (src) => encode(src, true);
|
|
var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
|
|
var cb_btou = (cccc) => {
|
|
switch (cccc.length) {
|
|
case 4:
|
|
var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset = cp - 65536;
|
|
return _fromCC((offset >>> 10) + 55296) + _fromCC((offset & 1023) + 56320);
|
|
case 3:
|
|
return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
|
|
default:
|
|
return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
|
|
}
|
|
};
|
|
var btou = (b) => b.replace(re_btou, cb_btou);
|
|
var atobPolyfill = (asc) => {
|
|
asc = asc.replace(/\s+/g, "");
|
|
if (!b64re.test(asc))
|
|
throw new TypeError("malformed base64.");
|
|
asc += "==".slice(2 - (asc.length & 3));
|
|
let u24, bin = "", r1, r2;
|
|
for (let i = 0; i < asc.length; ) {
|
|
u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]);
|
|
bin += r1 === 64 ? _fromCC(u24 >> 16 & 255) : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255) : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
|
|
}
|
|
return bin;
|
|
};
|
|
var _atob = _hasatob ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
|
|
var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a), (c) => c.charCodeAt(0));
|
|
var toUint8Array = (a) => _toUint8Array(_unURI(a));
|
|
var _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a));
|
|
var _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/"));
|
|
var decode = (src) => _decode(_unURI(src));
|
|
var isValid = (src) => {
|
|
if (typeof src !== "string")
|
|
return false;
|
|
const s = src.replace(/\s+/g, "").replace(/={0,2}$/, "");
|
|
return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
|
|
};
|
|
var _noEnum = (v) => {
|
|
return {
|
|
value: v,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
};
|
|
};
|
|
var extendString = function() {
|
|
const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body));
|
|
_add("fromBase64", function() {
|
|
return decode(this);
|
|
});
|
|
_add("toBase64", function(urlsafe) {
|
|
return encode(this, urlsafe);
|
|
});
|
|
_add("toBase64URI", function() {
|
|
return encode(this, true);
|
|
});
|
|
_add("toBase64URL", function() {
|
|
return encode(this, true);
|
|
});
|
|
_add("toUint8Array", function() {
|
|
return toUint8Array(this);
|
|
});
|
|
};
|
|
var extendUint8Array = function() {
|
|
const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));
|
|
_add("toBase64", function(urlsafe) {
|
|
return fromUint8Array(this, urlsafe);
|
|
});
|
|
_add("toBase64URI", function() {
|
|
return fromUint8Array(this, true);
|
|
});
|
|
_add("toBase64URL", function() {
|
|
return fromUint8Array(this, true);
|
|
});
|
|
};
|
|
var extendBuiltins = () => {
|
|
extendString();
|
|
extendUint8Array();
|
|
};
|
|
var gBase64 = {
|
|
version,
|
|
VERSION: VERSION5,
|
|
atob: _atob,
|
|
atobPolyfill,
|
|
btoa: _btoa,
|
|
btoaPolyfill,
|
|
fromBase64: decode,
|
|
toBase64: encode,
|
|
encode,
|
|
encodeURI: encodeURI2,
|
|
encodeURL: encodeURI2,
|
|
utob,
|
|
btou,
|
|
decode,
|
|
isValid,
|
|
fromUint8Array,
|
|
toUint8Array,
|
|
extendString,
|
|
extendUint8Array,
|
|
extendBuiltins
|
|
};
|
|
|
|
// Snippet-downloader/downloader.ts
|
|
var import_obsidian3 = __toModule(require("obsidian"));
|
|
function fetchListSnippet(repoRecur, snippetList, settings, repoPath) {
|
|
return __async(this, null, function* () {
|
|
for (const data of repoRecur.data.tree) {
|
|
if (data.path.endsWith(".css") && !searchExcluded(settings.excludedSnippet, data.path) && data.path != "obsidian.css" && !searchExcluded(settings.errorSnippet, data.path)) {
|
|
const snippetName = data.path;
|
|
const snippetLastUpdate = yield grabLastCommitDate(repoPath, data.path);
|
|
snippetList.push({
|
|
name: snippetName,
|
|
lastUpdate: snippetLastUpdate
|
|
});
|
|
}
|
|
}
|
|
return snippetList;
|
|
});
|
|
}
|
|
function grabLastCommitInfo(repoPath, filepath) {
|
|
return __async(this, null, function* () {
|
|
const repoName = repoPath.replace("https://github.com/", "");
|
|
const url = `https://api.github.com/repos/${repoName}/commits?path=${encodeURIComponent(filepath)}&page=1&per_page=1`;
|
|
try {
|
|
const response = yield (0, import_obsidian3.request)({ url });
|
|
return response === "404: Not Found" ? null : JSON.parse(response);
|
|
} catch (error) {
|
|
console.log("error in grabcommitinfo", error);
|
|
}
|
|
});
|
|
}
|
|
function grabLastCommitDate(repoPath, filepath) {
|
|
return __async(this, null, function* () {
|
|
const test = yield grabLastCommitInfo(repoPath, filepath);
|
|
console.log(`Testing from ${repoPath} : ${filepath} => ${test[0].commit.author.date}`);
|
|
if (test[0].commit.author.date) {
|
|
return test[0].commit.author.date;
|
|
} else {
|
|
return "";
|
|
}
|
|
});
|
|
}
|
|
function listSnippetfromRepo(repoPath, settings) {
|
|
return __async(this, null, function* () {
|
|
const octokit = new Octokit();
|
|
const repo = repoPath.replace("https://github.com/", "");
|
|
const owner = repo.split("/")[0];
|
|
const repoName = repo.split("/")[1];
|
|
console.log(`Repo: ${repoPath}, owner: ${owner}, repoName: ${repoName}`);
|
|
const snippetList = [];
|
|
try {
|
|
const repoRecur = yield octokit.request("GET /repos/{owner}/{repo}/git/trees/{tree_sha}", {
|
|
owner,
|
|
repo: repoName,
|
|
tree_sha: "main",
|
|
recursive: "true"
|
|
});
|
|
return yield fetchListSnippet(repoRecur, snippetList, settings, repoPath);
|
|
} catch (e) {
|
|
try {
|
|
const repoRecur = yield octokit.request("GET /repos/{owner}/{repo}/git/trees/{tree_sha}", {
|
|
owner,
|
|
repo: repoName,
|
|
tree_sha: "main",
|
|
recursive: "true"
|
|
});
|
|
return yield fetchListSnippet(repoRecur, snippetList, settings, repoPath);
|
|
} catch (e2) {
|
|
console.log(e2);
|
|
return [];
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function checkLastUpdate(snippetName, repoPath) {
|
|
return __async(this, null, function* () {
|
|
const oldDate = new Date(snippetName.lastUpdate);
|
|
const newDate = new Date(yield grabLastCommitDate(repoPath, snippetName.name));
|
|
return oldDate < newDate;
|
|
});
|
|
}
|
|
function downloadSnippet(repoPath, snippetName, vault) {
|
|
return __async(this, null, function* () {
|
|
const repo = repoPath.replace("https://github.com/", "");
|
|
const owner = repo.split("/")[0];
|
|
const repoName = repo.split("/")[1];
|
|
const octokit = new Octokit();
|
|
const fileName = basename(snippetName);
|
|
const filePath = (0, import_obsidian3.normalizePath)(vault.configDir + "/snippets/" + fileName);
|
|
try {
|
|
const file = yield octokit.request("GET /repos/{owner}/{repo}/contents/{path}", {
|
|
owner,
|
|
repo: repoName,
|
|
path: snippetName
|
|
});
|
|
console.log(file.status);
|
|
if (file.status === 200) {
|
|
const fileContent = gBase64.decode(file.data.content);
|
|
const adapter = vault.adapter;
|
|
yield adapter.write(filePath, fileContent);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Snippet-downloader/addSnippets.ts
|
|
function addSnippet(repoPath, settings, vault) {
|
|
return __async(this, null, function* () {
|
|
const snippetList = settings.snippetList;
|
|
let excludedSnippet = settings.errorSnippet;
|
|
const catchErrors = [];
|
|
if (!snippetList.some((snippet) => snippet.repo === repoPath)) {
|
|
const newSnippetList = yield listSnippetfromRepo(repoPath, settings);
|
|
if (newSnippetList.length === 0) {
|
|
new import_obsidian4.Notice("Error \u{1F63F}, snippet or repository not found");
|
|
return snippetList;
|
|
}
|
|
snippetList.push({
|
|
repo: repoPath,
|
|
snippetsContents: yield listSnippetfromRepo(repoPath, settings)
|
|
});
|
|
const snippet = snippetList.find((snippet2) => snippet2.repo === repoPath);
|
|
for (const snippetContents of snippet.snippetsContents) {
|
|
const success = yield downloadSnippet(repoPath, snippetContents.name, vault);
|
|
if (!success) {
|
|
excludedSnippet += snippetContents.name.replace(".css", "") + ", ";
|
|
catchErrors.push(snippetContents.name.replace(".css", ""));
|
|
}
|
|
}
|
|
let messageNotice = `Successfully added ${repoPath}. ${newSnippetList.length} snippets added. \u{1F389}`;
|
|
if (catchErrors.length > 0) {
|
|
messageNotice += `
|
|
${catchErrors.length} snippets not added\u{1F63F}: ${catchErrors.join(", ")}`;
|
|
}
|
|
new import_obsidian4.Notice(messageNotice);
|
|
return [snippetList, excludedSnippet];
|
|
}
|
|
new import_obsidian4.Notice("Error : this repo is already in the list \u{1F63F}");
|
|
return [snippetList, excludedSnippet];
|
|
});
|
|
}
|
|
function updateRepo(repoPath, snippetList, vault, excludedSnippets, errorSnippets) {
|
|
return __async(this, null, function* () {
|
|
const snippet = snippetList.find((snippet2) => snippet2.repo === repoPath);
|
|
if (snippet) {
|
|
for (const snippetContent of snippet.snippetsContents) {
|
|
if ((yield checkLastUpdate(snippetContent, repoPath)) && snippetContent.name !== "obsidian.css" && !searchExcluded(excludedSnippets, snippetContent.name) && !searchExcluded(errorSnippets, snippetContent.name)) {
|
|
const successDownloaded = yield downloadSnippet(repoPath, snippetContent.name, vault);
|
|
if (successDownloaded) {
|
|
snippetContent.lastUpdate = yield grabLastCommitDate(repoPath, snippetContent.name);
|
|
} else {
|
|
errorSnippets += snippetContent.name.replace(".css", "") + ", ";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
snippetList = removeSnippetFromExcluded(repoPath, snippetList, errorSnippets, excludedSnippets);
|
|
new import_obsidian4.Notice(`${repoPath} successfully updated \u{1F389}`);
|
|
return [snippetList, errorSnippets];
|
|
});
|
|
}
|
|
function updateSpecificSnippet(item, settings) {
|
|
return __async(this, null, function* () {
|
|
let listSnippet = settings.snippetList;
|
|
let excludedSnippet = settings.errorSnippet;
|
|
const snippet = listSnippet.find((snippet2) => snippet2.repo === item.repo);
|
|
const snippetsRep = snippet.snippetsContents.find((snippet2) => snippet2.name === item.snippetPath);
|
|
if (yield checkLastUpdate(snippetsRep, item.repo)) {
|
|
const successDownload = yield downloadSnippet(item.repo, snippetsRep.name, this.app.vault);
|
|
if (successDownload) {
|
|
snippetsRep.lastUpdate = yield grabLastCommitDate(item.repo, snippetsRep.name);
|
|
new import_obsidian4.Notice(`${basename(item.snippetPath)} has been updated \u{1F389}`);
|
|
return [
|
|
listSnippet,
|
|
excludedSnippet
|
|
];
|
|
} else {
|
|
excludedSnippet = excludedSnippet + item.snippetPath.replace(".css", "") + ", ";
|
|
listSnippet = removeSnippetFromExcluded(item.repo, listSnippet, excludedSnippet, settings.excludedSnippet);
|
|
return [
|
|
listSnippet,
|
|
excludedSnippet
|
|
];
|
|
}
|
|
}
|
|
listSnippet = removeSnippetFromExcluded(item.repo, listSnippet, excludedSnippet, settings.excludedSnippet);
|
|
new import_obsidian4.Notice(`${basename(item.snippetPath)} is already up to date \u{1F4A1}`);
|
|
return [
|
|
listSnippet,
|
|
excludedSnippet
|
|
];
|
|
});
|
|
}
|
|
|
|
// Snippet-downloader/modals/updateSnippets.ts
|
|
var import_obsidian5 = __toModule(require("obsidian"));
|
|
function getAllRepo(settings) {
|
|
const repoAll = [];
|
|
for (const repo of settings.snippetList) {
|
|
repoAll.push({
|
|
repoName: repo.repo,
|
|
repoUrl: ""
|
|
});
|
|
}
|
|
return repoAll;
|
|
}
|
|
function getAllSnippet(settings) {
|
|
const allSnippet = [];
|
|
for (const snippet of settings.snippetList) {
|
|
for (const snippetContent of snippet.snippetsContents) {
|
|
if (snippetContent.name !== "obsidian.css" && !searchExcluded(settings.excludedSnippet, snippetContent.name) && !searchExcluded(settings.errorSnippet, snippetContent.name)) {
|
|
allSnippet.push({
|
|
repo: snippet.repo,
|
|
snippetPath: snippetContent.name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return allSnippet;
|
|
}
|
|
var RepoDownloader = class extends import_obsidian5.FuzzySuggestModal {
|
|
constructor(app, settings, plugin) {
|
|
super(app);
|
|
this.settings = settings;
|
|
this.plugin = plugin;
|
|
}
|
|
getItemText(item) {
|
|
return item.repoName;
|
|
}
|
|
getItems() {
|
|
return getAllRepo(this.settings);
|
|
}
|
|
onChooseItem(item, evt) {
|
|
return __async(this, null, function* () {
|
|
const allSettings = yield updateRepo(item.repoName, this.settings.snippetList, this.app.vault, this.settings.excludedSnippet, this.settings.errorSnippet);
|
|
yield this.plugin.updateList(allSettings);
|
|
});
|
|
}
|
|
};
|
|
var SpecificSnippetDownloader = class extends import_obsidian5.FuzzySuggestModal {
|
|
constructor(app, settings, plugin) {
|
|
super(app);
|
|
this.settings = settings;
|
|
this.plugin = plugin;
|
|
}
|
|
getItemText(item) {
|
|
return basename(item.snippetPath);
|
|
}
|
|
getItems() {
|
|
return getAllSnippet(this.settings);
|
|
}
|
|
onChooseItem(item, evt) {
|
|
return __async(this, null, function* () {
|
|
const newList = yield updateSpecificSnippet(item, this.settings);
|
|
yield this.plugin.updateList(newList);
|
|
});
|
|
}
|
|
};
|
|
|
|
// Snippet-downloader/modals/excludeSnippet.ts
|
|
var import_obsidian6 = __toModule(require("obsidian"));
|
|
function getExcludedSnippets(settings) {
|
|
const allSnippet = [];
|
|
for (const snippet of settings.snippetList) {
|
|
for (const snippetContent of snippet.snippetsContents) {
|
|
if (snippetContent.name !== "obsidian.css" && !searchExcluded(settings.excludedSnippet, snippetContent.name) && !searchExcluded(settings.errorSnippet, snippetContent.name)) {
|
|
allSnippet.push({
|
|
repo: snippet.repo,
|
|
snippetPath: snippetContent.name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return allSnippet;
|
|
}
|
|
function addExcludedSnippet(item, settings) {
|
|
return __async(this, null, function* () {
|
|
let excludedSnippet = settings.excludedSnippet;
|
|
excludedSnippet = excludedSnippet + ", " + item.snippetPath;
|
|
const snippetList = removeSnippetFromExcluded(item.repo, settings.snippetList, settings.errorSnippet, excludedSnippet);
|
|
return [snippetList, excludedSnippet];
|
|
});
|
|
}
|
|
var ExcludeSnippet = class extends import_obsidian6.FuzzySuggestModal {
|
|
constructor(app, settings, plugin) {
|
|
super(app);
|
|
this.settings = settings;
|
|
this.plugin = plugin;
|
|
}
|
|
getItemText(item) {
|
|
return basename(item.snippetPath);
|
|
}
|
|
getItems() {
|
|
return getExcludedSnippets(this.settings);
|
|
}
|
|
onChooseItem(item, evt) {
|
|
return __async(this, null, function* () {
|
|
const newSettings = yield addExcludedSnippet(item, this.settings);
|
|
yield this.plugin.updateList(newSettings);
|
|
new import_obsidian6.Notice(`${basename(item.snippetPath)} has been excluded! \u{1F389}`);
|
|
});
|
|
}
|
|
};
|
|
|
|
// Snippet-downloader/settings.ts
|
|
var DEFAULT_SETTINGS = {
|
|
snippetList: [],
|
|
excludedSnippet: "",
|
|
errorSnippet: ""
|
|
};
|
|
function getDetailsState(name) {
|
|
for (let i = 0; i < document.getElementsByTagName("details").length; i++) {
|
|
const details = document.getElementsByTagName("details")[i];
|
|
if (details.innerText.split("\n")[0] === name) {
|
|
return details.hasAttribute("open");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function openDetails(name, detailsState) {
|
|
const allDetails = document.getElementsByTagName("details");
|
|
for (let i = 0; i < allDetails.length; i++) {
|
|
const details = allDetails[i];
|
|
if (details.innerText.split("\n")[0] === name && detailsState) {
|
|
details.setAttr("open", "true");
|
|
details.open = true;
|
|
details.setAttribute("open", "true");
|
|
} else if (details.innerText.split("\n")[0] === name && !detailsState) {
|
|
details.removeAttribute("open");
|
|
details.setAttribute("open", "false");
|
|
}
|
|
}
|
|
}
|
|
var SnippetDownloaderTabs = class extends import_obsidian7.PluginSettingTab {
|
|
constructor(app, plugin) {
|
|
super(app, plugin);
|
|
this.plugin = plugin;
|
|
}
|
|
display() {
|
|
const { containerEl } = this;
|
|
containerEl.empty();
|
|
const allSnippets = getAllSnippet(this.plugin.settings);
|
|
containerEl.createEl("h2", { text: "Snippet Manager Settings" });
|
|
const desc_excluder = document.createDocumentFragment();
|
|
desc_excluder.createEl("span", null, (span) => {
|
|
span.innerText = "Type the snippet name you want to exclude from the list, without the extension.\nYou can also use regex, for example: ";
|
|
span.createEl("code", { text: "^(.*)$" });
|
|
span.createEl("span", { text: " will match all snippets.\n\n" });
|
|
span.createEl("a", null, (link) => {
|
|
link.innerText = "You can check your regex here.";
|
|
link.href = "https://regex101.com/";
|
|
});
|
|
});
|
|
new import_obsidian7.Setting(containerEl).setName("Excluded Snippet").setDesc(desc_excluder).addTextArea((text) => text.setPlaceholder("BadCSS I hate, badCSS*").setValue(this.plugin.settings.excludedSnippet).onChange((value) => __async(this, null, function* () {
|
|
this.plugin.settings.excludedSnippet = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
const desc_plugins = document.createDocumentFragment();
|
|
desc_plugins.createEl("span", {
|
|
text: `The following is a list of the repository added via the command palette `
|
|
});
|
|
desc_plugins.createEl("div", {
|
|
text: `Click the x button next to a repository to remove it from the list.`
|
|
});
|
|
desc_plugins.createEl("b", { text: "Note: " });
|
|
desc_plugins.createEl("span", { text: "This does not delete the linked snippet, this should be done from your " });
|
|
desc_plugins.createEl("code", { text: ".obsidian/snippets" }).setAttribute("style", "font-family: var(--font-monospace)");
|
|
desc_plugins.createEl("span", { text: " folder" });
|
|
new import_obsidian7.Setting(containerEl).setName("Repository Snippet List").setDesc(desc_plugins).addButton((btn) => {
|
|
btn.setIcon("plus").setTooltip("Add new repository").onClick(() => __async(this, null, function* () {
|
|
new SnippetDownloaderModals(this.app, (result) => __async(this, null, function* () {
|
|
if (result) {
|
|
const newSettings = yield addSnippet(result.trim(), this.plugin.settings, this.app.vault);
|
|
yield this.plugin.updateList(newSettings);
|
|
const detailState = getDetailsState(result);
|
|
this.display();
|
|
openDetails(result, detailState);
|
|
}
|
|
})).open();
|
|
}));
|
|
}).addButton((btn) => {
|
|
btn.setIcon("install").setTooltip("Update all repository").onClick(() => __async(this, null, function* () {
|
|
this.plugin.updateAllSnippets();
|
|
}));
|
|
});
|
|
for (const repoPath of this.plugin.settings.snippetList) {
|
|
const details = containerEl.createEl("details");
|
|
const repoName = repoPath.repo.replace("https://github.com/", "");
|
|
const summary = details.createEl("summary", { text: repoName });
|
|
summary.addClass("snippets-downloader-summary");
|
|
new import_obsidian7.Setting(summary).setClass("snippets-downloader-options").addButton((btn) => {
|
|
btn.setClass("snippets-downloader-options-button").setIcon("cross").setTooltip("Delete this repository from the list").onClick(() => __async(this, null, function* () {
|
|
btn.buttonEl.parentElement.remove();
|
|
const newSettings = removeSnippet(repoPath.repo, this.plugin.settings.snippetList, this.plugin.settings.errorSnippet);
|
|
yield this.plugin.updateList(newSettings);
|
|
const detailState = getDetailsState(repoName);
|
|
this.display();
|
|
openDetails(repoName, detailState);
|
|
}));
|
|
}).addButton((btn) => {
|
|
btn.setClass("snippets-downloader-options-button").setIcon("sync").setTooltip("Update this repository").onClick(() => __async(this, null, function* () {
|
|
const allSettings = yield updateRepo(repoPath.repo, this.plugin.settings.snippetList, this.app.vault, this.plugin.settings.excludedSnippet, this.plugin.settings.errorSnippet);
|
|
yield this.plugin.updateList(allSettings);
|
|
}));
|
|
});
|
|
for (const snippets of repoPath.snippetsContents) {
|
|
new import_obsidian7.Setting(details).setName(basename(snippets.name)).setClass("snippets-downloader-settings").addExtraButton((btn) => {
|
|
btn.setTooltip("Update this snippet").setIcon("install").onClick(() => __async(this, null, function* () {
|
|
const updatedList = yield updateSpecificSnippet(allSnippets.find((s) => snippets.name === s.snippetPath), this.plugin.settings);
|
|
yield this.plugin.updateList(updatedList);
|
|
}));
|
|
}).addExtraButton((btn) => {
|
|
btn.setTooltip("Remove this snippet").setIcon("trash").onClick(() => __async(this, null, function* () {
|
|
btn.extraSettingsEl.parentElement.parentElement.remove();
|
|
const updatedList = yield addExcludedSnippet(getExcludedSnippets(this.plugin.settings).find((s) => snippets.name === s.snippetPath), this.plugin.settings);
|
|
yield this.plugin.updateList(updatedList);
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Snippet-downloader/main.ts
|
|
var snippetDownloader = class extends import_obsidian8.Plugin {
|
|
updateAllSnippets() {
|
|
return __async(this, null, function* () {
|
|
if (this.settings.snippetList.length > 0) {
|
|
const snippetList = this.settings.snippetList;
|
|
const errorSnippet = this.settings.errorSnippet;
|
|
const excludedSnippet = this.settings.excludedSnippet;
|
|
let updatedSettings = [errorSnippet, snippetList];
|
|
for (const repoName of snippetList) {
|
|
updatedSettings = yield updateRepo(repoName.repo, snippetList, this.app.vault, excludedSnippet, errorSnippet);
|
|
this.settings.snippetList = updatedSettings[1];
|
|
this.settings.errorSnippet = updatedSettings[0];
|
|
}
|
|
yield this.saveSettings();
|
|
}
|
|
});
|
|
}
|
|
updateList(newSettings) {
|
|
return __async(this, null, function* () {
|
|
this.settings.snippetList = newSettings[0];
|
|
this.settings.errorSnippet = newSettings[1];
|
|
yield this.saveSettings();
|
|
});
|
|
}
|
|
onload() {
|
|
return __async(this, null, function* () {
|
|
yield this.loadSettings();
|
|
this.addCommand({
|
|
id: "add-snippet",
|
|
name: "Adding new snippet",
|
|
callback: () => {
|
|
new SnippetDownloaderModals(this.app, (result) => __async(this, null, function* () {
|
|
if (result) {
|
|
const newSettings = yield addSnippet(result.trim(), this.settings, this.app.vault);
|
|
yield this.updateList(newSettings);
|
|
}
|
|
})).open();
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "update-all-snippets",
|
|
name: "Update all snippets",
|
|
checkCallback: (checking) => __async(this, null, function* () {
|
|
if (this.settings.snippetList.length > 0) {
|
|
if (!checking) {
|
|
const snippetList = this.settings.snippetList;
|
|
const errorSnippet = this.settings.errorSnippet;
|
|
const excludedSnippet = this.settings.excludedSnippet;
|
|
let updatedSettings = [errorSnippet, snippetList];
|
|
for (const repoName of snippetList) {
|
|
updatedSettings = yield updateRepo(repoName.repo, snippetList, this.app.vault, excludedSnippet, errorSnippet);
|
|
yield this.updateList(updatedSettings);
|
|
}
|
|
yield this.saveSettings();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
})
|
|
});
|
|
this.addCommand({
|
|
id: "update-specific-repo",
|
|
name: "Update specific repository",
|
|
hotkeys: [],
|
|
checkCallback: (checking) => {
|
|
if (this.settings.snippetList.length > 0) {
|
|
if (!checking) {
|
|
new RepoDownloader(this.app, this.settings, this).open();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "update-specific-snippet",
|
|
name: "Update specific snippet",
|
|
hotkeys: [],
|
|
checkCallback: (checking) => {
|
|
if (this.settings.snippetList.length > 0) {
|
|
if (!checking) {
|
|
new SpecificSnippetDownloader(this.app, this.settings, this).open();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "remove-specific-snippet",
|
|
name: "Exclude specific snippet",
|
|
hotkeys: [],
|
|
checkCallback: (checking) => {
|
|
if (this.settings.snippetList.length > 0) {
|
|
if (!checking) {
|
|
new ExcludeSnippet(this.app, this.settings, this).open();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
this.addSettingTab(new SnippetDownloaderTabs(this.app, this));
|
|
});
|
|
}
|
|
onunload() {
|
|
}
|
|
loadSettings() {
|
|
return __async(this, null, function* () {
|
|
this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData());
|
|
});
|
|
}
|
|
saveSettings() {
|
|
return __async(this, null, function* () {
|
|
yield this.saveData(this.settings);
|
|
});
|
|
}
|
|
};
|
|
/*!
|
|
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
|
|
*
|
|
* Copyright (c) 2014-2017, Jon Schlinkert.
|
|
* Released under the MIT License.
|
|
*/
|