// Base "class"
const superFactory = (name) => ({

  // Any propery on the "super" object will be a part of the final object
  superProp: '🦸',

  // Same for methods.
  someSuperMethod() {
    console.log(`I'm ${name}!`)
  },

  // We can implement methods meant to be overridden (but should we?)
  someOverrideMethod() {
    throw new Error('Not Implemented')
  }
});

// Function arguments are like constructor arguments
const finalFactory = (configProp) => {
  // private things live outside the return value
  const privateProp = '🔐';

  // internal state
  let accessCount = 0
  let history = [configProp]


  return {
    // We mimic inheritance by spreading the result of the pseudo base class
    ...superFactory('super'),

    // override a method from the pseudo base class
    someOverrideMethod() {
      console.log(`I override the method of the same name in superFactory`)
    },

    // regular object property
    finalProp: '🪦',

	// regular object method
    someMethod() {
      console.log(`I'm only a member of the finalFactory object`);
    },

    // a property with just a getter cannot be overridden
    get finalProp() {
      return privateProp;
    },
    
    // a properties with a getter and a setter can perform side effects
    get configProp() {
      accessCount++
      return configProp;
    },

    // It can also keep state.
    set configProp(newVal) {
      history.push(newVal)
      configProp = newVal;
    },
    
    // We can have dynamic keys.
    get [finalFactory.historyKey]() {
      return history;
    }

  }
}

// Static methods and properties are a thing too.
finalFactory.historyKey = Symbol('history');

const object = {};

const factory = () => ({});

const language = {
  name: 'JavaScript'
};

const languageFactory = () => ({
  name: 'JavaScript'
});

const languageFactory = (name) => ({ name });
const js = languageFactory('JavaScript') // { name: 'JavaScript' }

// This slide uses Auto-Animate to animate between
// two different code blocks
const distanceBetween = ( p1, p2 ) => {
 // TODO
}

distanceBetween([10,10], [50,50])

// Measure the distance between two points
const distanceBetween = ( p1, p2 ) => {
  const dx = p1[0]-p2[0];
  const dy = p1[1]-p2[1];

  return Math.sqrt( dx*dx + dy*dy );
}

distanceBetween([10,10], [50,50])