semlinker

interface Command {
  name: string;
  execute(args: any): any;
}

class OpenUrlCommand implements Command {
  name = "openUrl";
  execute(args: any) {
    console.log(`Open url: ${args[0]}`);
  }

semlinker

interface Strategy {
  authenticate(args: any[]): boolean;
}

class Authenticator {
  strategies: Record<string, Strategy> = {};

  use(name: string, strategy: Strategy) {
    this.strategies[name] = strategy;
  }

semlinker

type CacheItem = {
  now: number;
  value: string;
  maxAge: number;
};

class LocalStorageProxy {
  setItem(key: string, value: unknown, maxAge: number = 0) {
    localStorage.setItem(
      key,

semlinker

class HttpServiceProxy {
  private httpService: HttpService;
  private dataCache: Map<string, any> = new Map();

  constructor() {
    this.httpService = new HttpService();
  }

  async sendRequest(method: string, url: string, body?: BodyInit) {
    const cacheKey = method + ":" + url;

semlinker

class Client {
  private shapeFacade: ShapeFacade;
  constructor() {
    this.shapeFacade = new ShapeFacade();
  }

  drawShapes() {
    this.shapeFacade.drawCircle();
    this.shapeFacade.drawRectangle();
    this.shapeFacade.drawTriangle();

semlinker

class ShapeFacade {
  private circle: Shape;
  private rectangle: Shape;
  private triangle: Shape;

  constructor() {
    this.circle = new Circle();
    this.rectangle = new Rectangle();
    this.triangle = new Triangle();
  }

semlinker

interface Shape {
  draw(): void;
}

class Circle implements Shape {
  draw(): void {
    console.log("Draw circle");
  }
}

semlinker

class UPhoneFlyweight {
  constructor(model: string, screen: number, memory: number) {}
}

class FlyweightFactory {
  public phonesMap: Map<string, UPhoneFlyweight> = new Map();

  public get(model: string, screen: number, memory: number): UPhoneFlyweight {
    const key = model + screen + memory;
    if (!this.phonesMap.has(key)) {

semlinker

function Builder(typeOrTemplate, template) {
  let type;
  if (typeOrTemplate instanceof Function) {
    type = typeOrTemplate;
  } else {
    template = typeOrTemplate;
  }
  const built = template ? Object.assign({}, template) : {};
  const builder = new Proxy(
    {},

semlinker

function sandbox(code) {
  code = "with (sandbox) {" + code + "}";
  const fn = new Function("sandbox", code);

  return function (sandbox) {
    const sandboxProxy = new Proxy(sandbox, {
      has(target, key) {
        return true;
      },
      get(target, key) {