mirror of
https://github.com/neocities/neocities.git
synced 2025-07-23 19:10:40 +02:00
added monaco code to public js folder and removed cdn
This commit is contained in:
BanceDev
parent
165e17f844
commit
4a7483509e
1387 changed files with 1185013 additions and 24 deletions
355
public/js/monaco/esm/vs/base/common/lifecycle.js
Normal file
355
public/js/monaco/esm/vs/base/common/lifecycle.js
Normal file
|
|
@ -0,0 +1,355 @@
|
|||
import { createSingleCallFunction } from './functional.js';
|
||||
import { Iterable } from './iterator.js';
|
||||
// #region Disposable Tracking
|
||||
/**
|
||||
* Enables logging of potentially leaked disposables.
|
||||
*
|
||||
* A disposable is considered leaked if it is not disposed or not registered as the child of
|
||||
* another disposable. This tracking is very simple an only works for classes that either
|
||||
* extend Disposable or use a DisposableStore. This means there are a lot of false positives.
|
||||
*/
|
||||
const TRACK_DISPOSABLES = false;
|
||||
let disposableTracker = null;
|
||||
export function setDisposableTracker(tracker) {
|
||||
disposableTracker = tracker;
|
||||
}
|
||||
if (TRACK_DISPOSABLES) {
|
||||
const __is_disposable_tracked__ = '__is_disposable_tracked__';
|
||||
setDisposableTracker(new class {
|
||||
trackDisposable(x) {
|
||||
const stack = new Error('Potentially leaked disposable').stack;
|
||||
setTimeout(() => {
|
||||
if (!x[__is_disposable_tracked__]) {
|
||||
console.log(stack);
|
||||
}
|
||||
}, 3000);
|
||||
}
|
||||
setParent(child, parent) {
|
||||
if (child && child !== Disposable.None) {
|
||||
try {
|
||||
child[__is_disposable_tracked__] = true;
|
||||
}
|
||||
catch {
|
||||
// noop
|
||||
}
|
||||
}
|
||||
}
|
||||
markAsDisposed(disposable) {
|
||||
if (disposable && disposable !== Disposable.None) {
|
||||
try {
|
||||
disposable[__is_disposable_tracked__] = true;
|
||||
}
|
||||
catch {
|
||||
// noop
|
||||
}
|
||||
}
|
||||
}
|
||||
markAsSingleton(disposable) { }
|
||||
});
|
||||
}
|
||||
export function trackDisposable(x) {
|
||||
disposableTracker?.trackDisposable(x);
|
||||
return x;
|
||||
}
|
||||
export function markAsDisposed(disposable) {
|
||||
disposableTracker?.markAsDisposed(disposable);
|
||||
}
|
||||
function setParentOfDisposable(child, parent) {
|
||||
disposableTracker?.setParent(child, parent);
|
||||
}
|
||||
function setParentOfDisposables(children, parent) {
|
||||
if (!disposableTracker) {
|
||||
return;
|
||||
}
|
||||
for (const child of children) {
|
||||
disposableTracker.setParent(child, parent);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Indicates that the given object is a singleton which does not need to be disposed.
|
||||
*/
|
||||
export function markAsSingleton(singleton) {
|
||||
disposableTracker?.markAsSingleton(singleton);
|
||||
return singleton;
|
||||
}
|
||||
/**
|
||||
* Check if `thing` is {@link IDisposable disposable}.
|
||||
*/
|
||||
export function isDisposable(thing) {
|
||||
return typeof thing === 'object' && thing !== null && typeof thing.dispose === 'function' && thing.dispose.length === 0;
|
||||
}
|
||||
export function dispose(arg) {
|
||||
if (Iterable.is(arg)) {
|
||||
const errors = [];
|
||||
for (const d of arg) {
|
||||
if (d) {
|
||||
try {
|
||||
d.dispose();
|
||||
}
|
||||
catch (e) {
|
||||
errors.push(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (errors.length === 1) {
|
||||
throw errors[0];
|
||||
}
|
||||
else if (errors.length > 1) {
|
||||
throw new AggregateError(errors, 'Encountered errors while disposing of store');
|
||||
}
|
||||
return Array.isArray(arg) ? [] : arg;
|
||||
}
|
||||
else if (arg) {
|
||||
arg.dispose();
|
||||
return arg;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Combine multiple disposable values into a single {@link IDisposable}.
|
||||
*/
|
||||
export function combinedDisposable(...disposables) {
|
||||
const parent = toDisposable(() => dispose(disposables));
|
||||
setParentOfDisposables(disposables, parent);
|
||||
return parent;
|
||||
}
|
||||
/**
|
||||
* Turn a function that implements dispose into an {@link IDisposable}.
|
||||
*
|
||||
* @param fn Clean up function, guaranteed to be called only **once**.
|
||||
*/
|
||||
export function toDisposable(fn) {
|
||||
const self = trackDisposable({
|
||||
dispose: createSingleCallFunction(() => {
|
||||
markAsDisposed(self);
|
||||
fn();
|
||||
})
|
||||
});
|
||||
return self;
|
||||
}
|
||||
/**
|
||||
* Manages a collection of disposable values.
|
||||
*
|
||||
* This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
|
||||
* `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
|
||||
* store that has already been disposed of.
|
||||
*/
|
||||
export class DisposableStore {
|
||||
static { this.DISABLE_DISPOSED_WARNING = false; }
|
||||
constructor() {
|
||||
this._toDispose = new Set();
|
||||
this._isDisposed = false;
|
||||
trackDisposable(this);
|
||||
}
|
||||
/**
|
||||
* Dispose of all registered disposables and mark this object as disposed.
|
||||
*
|
||||
* Any future disposables added to this object will be disposed of on `add`.
|
||||
*/
|
||||
dispose() {
|
||||
if (this._isDisposed) {
|
||||
return;
|
||||
}
|
||||
markAsDisposed(this);
|
||||
this._isDisposed = true;
|
||||
this.clear();
|
||||
}
|
||||
/**
|
||||
* @return `true` if this object has been disposed of.
|
||||
*/
|
||||
get isDisposed() {
|
||||
return this._isDisposed;
|
||||
}
|
||||
/**
|
||||
* Dispose of all registered disposables but do not mark this object as disposed.
|
||||
*/
|
||||
clear() {
|
||||
if (this._toDispose.size === 0) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
dispose(this._toDispose);
|
||||
}
|
||||
finally {
|
||||
this._toDispose.clear();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Add a new {@link IDisposable disposable} to the collection.
|
||||
*/
|
||||
add(o) {
|
||||
if (!o) {
|
||||
return o;
|
||||
}
|
||||
if (o === this) {
|
||||
throw new Error('Cannot register a disposable on itself!');
|
||||
}
|
||||
setParentOfDisposable(o, this);
|
||||
if (this._isDisposed) {
|
||||
if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
|
||||
console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);
|
||||
}
|
||||
}
|
||||
else {
|
||||
this._toDispose.add(o);
|
||||
}
|
||||
return o;
|
||||
}
|
||||
/**
|
||||
* Deletes the value from the store, but does not dispose it.
|
||||
*/
|
||||
deleteAndLeak(o) {
|
||||
if (!o) {
|
||||
return;
|
||||
}
|
||||
if (this._toDispose.has(o)) {
|
||||
this._toDispose.delete(o);
|
||||
setParentOfDisposable(o, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Abstract base class for a {@link IDisposable disposable} object.
|
||||
*
|
||||
* Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of.
|
||||
*/
|
||||
export class Disposable {
|
||||
/**
|
||||
* A disposable that does nothing when it is disposed of.
|
||||
*
|
||||
* TODO: This should not be a static property.
|
||||
*/
|
||||
static { this.None = Object.freeze({ dispose() { } }); }
|
||||
constructor() {
|
||||
this._store = new DisposableStore();
|
||||
trackDisposable(this);
|
||||
setParentOfDisposable(this._store, this);
|
||||
}
|
||||
dispose() {
|
||||
markAsDisposed(this);
|
||||
this._store.dispose();
|
||||
}
|
||||
/**
|
||||
* Adds `o` to the collection of disposables managed by this object.
|
||||
*/
|
||||
_register(o) {
|
||||
if (o === this) {
|
||||
throw new Error('Cannot register a disposable on itself!');
|
||||
}
|
||||
return this._store.add(o);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Manages the lifecycle of a disposable value that may be changed.
|
||||
*
|
||||
* This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
|
||||
* also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
|
||||
*/
|
||||
export class MutableDisposable {
|
||||
constructor() {
|
||||
this._isDisposed = false;
|
||||
trackDisposable(this);
|
||||
}
|
||||
get value() {
|
||||
return this._isDisposed ? undefined : this._value;
|
||||
}
|
||||
set value(value) {
|
||||
if (this._isDisposed || value === this._value) {
|
||||
return;
|
||||
}
|
||||
this._value?.dispose();
|
||||
if (value) {
|
||||
setParentOfDisposable(value, this);
|
||||
}
|
||||
this._value = value;
|
||||
}
|
||||
/**
|
||||
* Resets the stored value and disposed of the previously stored value.
|
||||
*/
|
||||
clear() {
|
||||
this.value = undefined;
|
||||
}
|
||||
dispose() {
|
||||
this._isDisposed = true;
|
||||
markAsDisposed(this);
|
||||
this._value?.dispose();
|
||||
this._value = undefined;
|
||||
}
|
||||
}
|
||||
export class RefCountedDisposable {
|
||||
constructor(_disposable) {
|
||||
this._disposable = _disposable;
|
||||
this._counter = 1;
|
||||
}
|
||||
acquire() {
|
||||
this._counter++;
|
||||
return this;
|
||||
}
|
||||
release() {
|
||||
if (--this._counter === 0) {
|
||||
this._disposable.dispose();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
}
|
||||
export class ImmortalReference {
|
||||
constructor(object) {
|
||||
this.object = object;
|
||||
}
|
||||
dispose() { }
|
||||
}
|
||||
/**
|
||||
* A map the manages the lifecycle of the values that it stores.
|
||||
*/
|
||||
export class DisposableMap {
|
||||
constructor() {
|
||||
this._store = new Map();
|
||||
this._isDisposed = false;
|
||||
trackDisposable(this);
|
||||
}
|
||||
/**
|
||||
* Disposes of all stored values and mark this object as disposed.
|
||||
*
|
||||
* Trying to use this object after it has been disposed of is an error.
|
||||
*/
|
||||
dispose() {
|
||||
markAsDisposed(this);
|
||||
this._isDisposed = true;
|
||||
this.clearAndDisposeAll();
|
||||
}
|
||||
/**
|
||||
* Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.
|
||||
*/
|
||||
clearAndDisposeAll() {
|
||||
if (!this._store.size) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
dispose(this._store.values());
|
||||
}
|
||||
finally {
|
||||
this._store.clear();
|
||||
}
|
||||
}
|
||||
get(key) {
|
||||
return this._store.get(key);
|
||||
}
|
||||
set(key, value, skipDisposeOnOverwrite = false) {
|
||||
if (this._isDisposed) {
|
||||
console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack);
|
||||
}
|
||||
if (!skipDisposeOnOverwrite) {
|
||||
this._store.get(key)?.dispose();
|
||||
}
|
||||
this._store.set(key, value);
|
||||
}
|
||||
/**
|
||||
* Delete the value stored for `key` from this map and also dispose of it.
|
||||
*/
|
||||
deleteAndDispose(key) {
|
||||
this._store.get(key)?.dispose();
|
||||
this._store.delete(key);
|
||||
}
|
||||
[Symbol.iterator]() {
|
||||
return this._store[Symbol.iterator]();
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue