disco0

Some things that are "better" with this BetterPromise implementation:

• BetterPromise # then(..) accepts a BetterPromise (or Promise) instance passed directly, instead of requiring a function to return it, so that the promise is linked into the chain.

  var p = BetterPromise.resolve(42);
  
  var q = Promise.resolve(10);
  
  p.then(console.log).then(q).then(console.log);

disco0

// @virtual decorator function
function virtual( target: any, name: string)
{
    // symbol to keep the proxy handler value
    let sym = Symbol( name + "_proxy_handler");

    Object.defineProperty( target, name, {
        enumerable: true,
        
        get()

disco0

class Base
{
    @virtual a = 1;
    b = this.a;
}

class Derived extends Base
{
    a = 2;
}

disco0

export function virtual( target: any, name: string)
{
    // symbol to keep the proxy handler value
    let sym = Symbol( name + "_proxy_handler");

    Object.defineProperty( target, name, {
        enumerable: true,
        
        get()
        {

disco0

class VirtHandler
{
    target: any;
    
    get( t: any, p: PropertyKey, r: any): any
    {
        return this.target[p];
    }
}

disco0

class Base
{
    first = { v: 1 };
    second = () => this.first;
}

class Derived extends Base
{
    first = { v: 2 };
}

disco0

class Base
{
    first = { v: 1 };
    second = this.first;
}

class Derived extends Base
{
    first = { v: 2 };
}

disco0

/* This class wraps an iterator/iterable and allows the map/filter/reduce methods
 * to be used without being forced to make intermediate temporary arrays.
 * I've also implemented the flatten and flatmap functions for convenience
 */

class FunctionalIterator {
    constructor(source) {
        // Get iterator from source, if present.  Otherwise, assume that the source is an iterator
        this.source = source[Symbol.iterator] ? source[Symbol.iterator]() : source;
    }

disco0

/**
 * Extended version of MutationObserver that allows control of MutationRecord typing via type
 * parameter on (but not limited to) constructor. 
 *
 * I have used this to soothe the type checker on existing(/working) javascript code (using
 * HTMLElement for type parameter to cast mutation records as HTMLElements), however, similar to
 * ParentNode#querySelector without template literal type inferrence parsing the selector, I'd
 * imagine you can easily set an incorrect type for mutation records in a callback (until an
 * inference point is added).
 */

disco0

// ==UserScript==
// @name         Old Reddit, Forever
// @namespace    gitlab.com/disk0/userscript/reddit/old
// @version      0.1.0
// @author       disk0
// @include      /^https?:\/\/((?!old)[a-z][a-z\d_]*\.)?reddit\.com.*/
// @grant        none
// @run-at       document-start
// ==/UserScript==