Add files via upload

Author: Eggy115

cache.ts

@@ -0,0 +1,102 @@
+import { DocumentNode } from 'graphql';
+import { getFragmentQueryDocument } from 'apollo-utilities';
+
+import { DataProxy, Cache } from './types';
+
+export type Transaction<T> = (c: ApolloCache<T>) => void;
+
+export abstract class ApolloCache<TSerialized> implements DataProxy {
+  // required to implement
+  // core API
+  public abstract read<T>(query: Cache.ReadOptions): T;
+  public abstract write(write: Cache.WriteOptions): void;
+  public abstract diff<T>(query: Cache.DiffOptions): Cache.DiffResult<T>;
+  public abstract watch(watch: Cache.WatchOptions): () => void;
+  public abstract evict(query: Cache.EvictOptions): Cache.EvictionResult;
+  public abstract reset(): Promise<void>;
+
+  // intializer / offline / ssr API
+  /**
+   * Replaces existing state in the cache (if any) with the values expressed by
+   * `serializedState`.
+   *
+   * Called when hydrating a cache (server side rendering, or offline storage),
+   * and also (potentially) during hot reloads.
+   */
+  public abstract restore(
+    serializedState: TSerialized,
+  ): ApolloCache<TSerialized>;
+
+  /**
+   * Exposes the cache's complete state, in a serializable format for later restoration.
+   */
+  public abstract extract(optimistic: boolean): TSerialized;
+
+  // optimistic API
+  public abstract removeOptimistic(id: string): void;
+
+  // transactional API
+  public abstract performTransaction(
+    transaction: Transaction<TSerialized>,
+  ): void;
+  public abstract recordOptimisticTransaction(
+    transaction: Transaction<TSerialized>,
+    id: string,
+  ): void;
+
+  // optional API
+  public transformDocument(document: DocumentNode): DocumentNode {
+    return document;
+  }
+  // experimental
+  public transformForLink(document: DocumentNode): DocumentNode {
+    return document;
+  }
+
+  // DataProxy API
+  /**
+   *
+   * @param options
+   * @param optimistic
+   */
+  public readQuery<QueryType>(
+    options: DataProxy.Query,
+    optimistic: boolean = false,
+  ): QueryType {
+    return this.read({
+      query: options.query,
+      variables: options.variables,
+      optimistic,
+    });
+  }
+
+  public readFragment<FragmentType>(
+    options: DataProxy.Fragment,
+    optimistic: boolean = false,
+  ): FragmentType | null {
+    return this.read({
+      query: getFragmentQueryDocument(options.fragment, options.fragmentName),
+      variables: options.variables,
+      rootId: options.id,
+      optimistic,
+    });
+  }
+
+  public writeQuery(options: Cache.WriteQueryOptions): void {
+    this.write({
+      dataId: 'ROOT_QUERY',
+      result: options.data,
+      query: options.query,
+      variables: options.variables,
+    });
+  }
+
+  public writeFragment(options: Cache.WriteFragmentOptions): void {
+    this.write({
+      dataId: options.id,
+      result: options.data,
+      variables: options.variables,
+      query: getFragmentQueryDocument(options.fragment, options.fragmentName),
+    });
+  }
+}

classes.ts

@@ -0,0 +1,28 @@
+class Animal {
+    constructor(public name) { }
+    move(meters) {
+        alert(this.name + " moved " + meters + "m.");
+    }
+}
+
+class Snake extends Animal {
+    constructor(name) { super(name); }
+    move() {
+        alert("Slithering...");
+        super.move(5);
+    }
+}
+
+class Horse extends Animal {
+    constructor(name) { super(name); }
+    move() {
+        alert("Galloping...");
+        super.move(45);
+    }
+}
+
+var sam = new Snake("Sammy the Python")
+var tom: Animal = new Horse("Tommy the Palomino")
+
+sam.move()
+tom.move(34)

conditionParser.mts

@@ -0,0 +1,118 @@
+const thisFile = import.meta.url;
+
+const waitOneTick = await Promise.resolve();
+
+export function parse(
+    source: string
+  ): {
+    test: string;
+    consequent: string | null;
+    alternate: string | null;
+    hash: string | null;
+  } {
+    const PROTOCOL = "condition:";
+  
+    if (!source.startsWith(PROTOCOL, 0)) {
+      throw new Error(`Expected 'condition:' at index 0 (${source})`);
+    }
+  
+    let pos = PROTOCOL.length;
+  
+    skipWs();
+  
+    const test = eatRegExp(/[\w-]+/y);
+    if (!test) {
+      throw new Error(`Expected an identifier at index ${pos} (${source})`);
+    }
+  
+    skipWs();
+    expect("?");
+    skipWs();
+  
+    let consequent = null;
+    if (source[pos] === "(") {
+      consequent = eatParenthesized().trim() || null;
+      skipWs();
+    } else if (source[pos] !== ":") {
+      consequent = eatUntil(":").trimRight() || null;
+    }
+  
+    expect(":");
+    skipWs();
+  
+    let alternate = null;
+    if (pos < source.length) {
+      if (source[pos] === "(") {
+        alternate = eatParenthesized().trim() || null;
+        skipWs();
+      } else if (source[pos] !== ":") {
+        alternate = eatUntil("#").trimRight() || null;
+      }
+    }
+  
+    let hash = null;
+    if (pos < source.length && source[pos] === "#") {
+      pos++;
+      hash = eatRegExp(/\w+/y);
+      skipWs();
+    }
+  
+    if (pos !== source.length) {
+      throw new Error(`Unexpected '${source[pos]}' at index ${pos} (${source})`);
+    }
+  
+    return { test, consequent, alternate, hash };
+  
+    function expect(ch: string) {
+      if (source[pos] !== ch) {
+        throw new Error(`Expected '${ch}' at index ${pos} (${source})`);
+      }
+      pos++;
+    }
+  
+    function skipWs() {
+      eatRegExp(/\s*/y);
+    }
+  
+    function eatRegExp(re: RegExp) {
+      re.lastIndex = pos;
+      const match = re.exec(source);
+      if (!match) return null;
+  
+      pos += match[0].length;
+      return match[0];
+    }
+  
+    function eatUntil(end: string) {
+      const start = pos;
+      pos = source.indexOf(end, start);
+      if (pos === -1) pos = source.length;
+      return source.slice(start, pos);
+    }
+  
+    function eatParenthesized() {
+      expect("(");
+  
+      let depth = 1;
+      let contents = "";
+  
+      while (depth) {
+        if (pos === source.length) {
+          throw new Error(`Expected ')' at index ${pos} (${source})`);
+        }
+  
+        const ch = source[pos];
+  
+        if (ch === "(") depth++;
+        if (ch === ")") depth--;
+  
+        if (ch !== ")" || depth > 0) {
+          contents += ch;
+        }
+  
+        pos++;
+      }
+  
+      return contents;
+    }
+  }

hello.ts

@@ -0,0 +1 @@
+console.log("Hello, World!");

promisified_cp.cts

@@ -0,0 +1,12 @@
+import cp = require("child_process");
+
+export = function run(command: string): Promise<{ stdout: string; stderr: string }> {
+  const s = (b) => String(b).trim();
+
+  return new Promise((resolve, reject) => {
+    cp.exec(command, (error, stdout, stderr) => {
+      if (error) return reject(error);
+      resolve({ stdout: s(stdout), stderr: s(stderr) });
+    });
+  });
+}