import Vue, { VNode } from "vue";
import {
  compile,
  compileToFunctions,
  ssrCompile,
  ssrCompileToFunctions,
  parseComponent,
  generateCodeFrame
} from "./";

// check compile options
const compiled = compile("<div>hi</div>", {
  outputSourceRange: true,
  preserveWhitespace: false,
  whitespace: 'condense',
  modules: [
    {
      preTransformNode: el => el,
      transformNode: el => el,
      postTransformNode: el => {
        el.tag = "p";
      },
      genData: el => el.tag,
      transformCode: (el, code) => code,
      staticKeys: ["test"]
    }
  ],
  directives: {
    test: (node, directiveMeta) => {
      node.tag;
      directiveMeta.value;
    }
  }
});

// can be passed to function constructor
new Function(compiled.render);
compiled.staticRenderFns.map(fn => new Function(fn));

// with outputSourceRange: true
// errors should be objects with range
compiled.errors.forEach(e => {
  console.log(e.msg)
})

// without option or without outputSourceRange: true, should be strings
const { errors } = compile(`foo`)
errors.forEach(e => {
  console.log(e.length)
})

const { errors: errors2 } = compile(`foo`, {})
errors2.forEach(e => {
  console.log(e.length)
})

const { errors: errors3 } = compile(`foo`, {
  outputSourceRange: false
})
errors3.forEach(e => {
  console.log(e.length)
})

const compiledFns = compileToFunctions("<div>hi</div>");

// can be passed to component render / staticRenderFns options
const vm = new Vue({
  data() {
    return {
      test: "Test"
    };
  },
  render: compiledFns.render,
  staticRenderFns: compiledFns.staticRenderFns
});

// can be called with component instance
const vnode: VNode = compiledFns.render.call(vm);

// check SFC parser
const desc = parseComponent("<template></template>", {
  pad: "space",
  deindent: false
});

const templateContent: string = desc.template!.content;
const scriptContent: string = desc.script!.content;
const styleContent: string = desc.styles.map(s => s.content).join("\n");

const codeframe: string = generateCodeFrame(`foobar`, 0, 4)