"use strict";

const log = require('fliplog');

const _require = require("../src"),
      compose = _require.compose; // const ChainedMap = require('../ChainedMap')
// const compose = require('../compose')


const PreComposed = compose();
let Composed = class Composed extends PreComposed {};
test('composable', () => {
  const map = new Composed({
    isParent: true
  });
  expect(map.parent).toEqual({
    isParent: true
  });
});
test('compose custom extensions', () => {
  let CustomTarget = class CustomTarget {
    constructor(parent) {
      this.ok = true;
    }

  };

  const CustomComposer = SuperClass => {
    let Customed = class Customed extends SuperClass {};
    return Customed;
  };

  const CustomComposed = compose(CustomTarget, [CustomComposer]);
  const map = new CustomComposed();
  expect(map.ok).toBe(true);
  expect(map instanceof CustomTarget).toBe(true);
});
test('clearable', () => {
  const map = new Composed({
    isParent: true
  }).set('eh', 'eh!');
  expect(map.entries()).toEqual({
    eh: 'eh!'
  });
  map.clear();
  expect(map.store).toEqual(new Map());
});
test('mergeable', () => {
  const map = new Composed({
    isParent: true
  }).extend(['igloo']).set('eh', 'eh!').set('eh2', 'eh2!').merge({
    dis: 1,
    eh: ['string-to-arr'],
    igloo: 0,
    neuw: Boolean
  });
  expect(map.entries()).toEqual({
    eh: ['string-to-arr'],
    eh2: 'eh2!',
    dis: 1,
    igloo: 0,
    neuw: Boolean
  });
});
test('.className', () => {
  expect.assertions(1);
  const chain = new Composed();
  expect(typeof chain.className === 'string').toBe(true);
});
test('extend class as decorator', () => {
  let CustomTarget = class CustomTarget {};

  const CustomComposer = SuperClass => {
    let Customed = class Customed extends SuperClass {};
    return Customed;
  };

  const CustomComposed = compose(CustomTarget, [CustomComposer]);
  let Target = class Target {
    get extended() {
      return true;
    }

  };
  let Target2 = class Target2 {
    eh() {}

    get extended2() {
      return true;
    }

  };
  const CT = compose(Target, undefined);
  let ComposedTarget = class ComposedTarget extends CT {};
  let ComposedTarget2 = class ComposedTarget2 extends compose(Target2) {};
  const map = new ComposedTarget({
    isParent: true
  });
  const map2 = new ComposedTarget2({
    isParent: true
  }); // log.prettyformat(new CustomComposed()).echo()
  // log.prettyformat(map).echo()
  // log.prettyformat(new ComposedTarget2()).echo()
  // log.data(new ComposedTarget2() instanceof ComposedTarget2).echo()
  // log.data(map instanceof Target).echo()

  expect(map.parent).toEqual({
    isParent: true
  });
  expect(map.extended).toBe(true);
});