var sketch = require('sketch/dom')
var async = require('sketch/async')
var DataSupplier = require('sketch/data-supplier')
var UI = require('sketch/ui')
var Settings = require('sketch/settings')

// a more convenient require which exposes everything (might be a bit slower)
var sketch = require('sketch')

var Document = require('sketch/dom').Document

var document = require('sketch/dom').getSelectedDocument()

// also exposed on Document
var document = Document.getSelectedDocument()

var documents = require('sketch/dom').getDocuments()

// also exposed on Document
var documents = Document.getDocuments()

var document = new Document()

// ask the user to select a document
Document.open((err, document) => {
  if (err) {
    // oh no, we failed to open the document
  }
  // if the user cancel the opening, `document` will be `undefined`
})

// open a sketch document at the specified path
Document.open('path/to/the/document.sketch', (err, document) => {
  if (err) {
    // oh no, we failed to open the document
  }
})

var layer = document.getLayerWithID(layerId)
if (layer) {
  // do something
}

var layers = document.getLayersNamed(name)
if (layers.length) {
  // do something
}

var sharedStyle = document.getSharedLayerStyleWithID(sharedStyleId)

var sharedStyle = document.getSharedTextStyleWithID(sharedStyleId)

var symbols = document.getSymbols()

var source = document.getSymbolMasterWithID(symbolInstance.symbolId)

document.centerOnLayer(layer)

document.save()

document.save('path/to/the/document.sketch')

document.save('path/to/the/document.sketch', (err) => {
  if (err) {
    // saving the document failed :(
  }
})

document.close()

// By default the method assigns a new color space
document.changeColorSpace(ColorSpace.sRGB)
console.log(document.colorSpace === ColorSpace.sRGB) // true

// Pass true as an optional second argument
// to convert instead of assign
document.changeColorSpace(ColorSpace.P3, true)
console.log(document.colorSpace === ColorSpace.P3) // true

// Alternatively, use the property setter (the behaviour
// here is to always assign the color space)
document.colorSpace = ColorSpace.P3
console.log(document.colorSpace === ColorSpace.P3) // true

// Create a document with a pre-defined color space
const p3Doc = new Document({ colorSpace: ColorSpace.P3 })

Document.SaveMode.SaveAs

document.save('path/to/the/document.sketch', {
  saveMode: Document.SaveMode.SaveAs,
})

Document.ColorSpace.Unmanaged
Document.ColorSpace.sRGB
Document.ColorSpace.P3

var Library = require('sketch/dom').Library

var libraries = require('sketch/dom').getLibraries()

// also exposed on Library
var libraries = Library.getLibraries()

var library = Library.getLibraryForDocumentAtPath(
  'path/to/existing/document.sketch'
)

Library.getRemoteLibraryWithRSS(
  'https://url/to/feed/rss.xml',
  (err, library) => {
    if (err) {
      // oh no, failed to load the library
    }
  }
)

library.remove()

var libDocument = library.getDocument()

var document = sketch.getSelectedDocument()
var symbolReferences = library.getImportableSymbolReferencesForDocument(
  document
)

var document = sketch.getSelectedDocument()
var stylesReferences = library.getImportableLayerStyleReferencesForDocument(
  document
)

var document = sketch.getSelectedDocument()
var stylesReferences = library.getImportableTextStyleReferencesForDocument(
  document
)

var document = sketch.getSelectedDocument()
var stylesReferences = library.getImportableSwatchReferencesForDocument(
  document
)

Library.LibraryType.LocalUser

var symbolReferences = library.getImportableSymbolReferencesForDocument(
  document
)

var symbol = symbolReference.import()
var style = sharedStyleReference.import()

Library.ImportableObjectType.Symbol

var Style = require('sketch/dom').Style

var shape = new Shape({
  style: {
    borders: [{ color: '#c0ffee' }],
  },
})

shape.style.fills = [
  {
    color: '#c0ffee',
    fillType: Style.FillType.Color,
  },
]

text.style.textUnderline = 'double dash-dot'

var defaultlineHeight = style.getDefaultLineHeight()

var isOutOfSync = style.isOutOfSyncWithSharedStyle(sharedStyle)

style.syncWithSharedStyle(sharedStyle)

var sharedStyle = styledLayer.sharedStyle
sharedStyle.style = style

Style.BlendingMode.Darken

shape.style.blur = {
  center: {
    x: 10,
    y: 20,
  },
  type: Style.BlurType.Motion,
  motionAngle: 10,
}

Style.BlurType.Background

shape.style.fills = [
  {
    color: '#c0ffee',
    fillType: Style.FillType.Color,
  },
]

Style.FillType.Color

Style.PatternFillType.Fit

shape.style.borders = [
  {
    color: '#c0ffee',
    fillType: Style.FillType.Color,
    position: Style.BorderPosition.Inside,
  },
]

Style.BorderPosition.Center

shape.style.borderOptions = {
  dashPattern: [20, 5, 20, 5],
}

Style.Arrowhead.OpenArrow

Style.LineEnd.Round

Style.LineJoin.Miter

shape.style.shadows = [
  {
    color: '#c0ffee',
    blur: 3,
  },
]

shape.style.innerShadows = [
  {
    color: '#c0ffee',
    blur: 3,
  },
]

shape.style.fills = [
  {
    fillType: Style.FillType.Gradient,
    gradient: {
      gradientType: Style.GradientType.Linear,
      from: {
        x: 0,
        y: 0,
      },
      to: {
        x: 50,
        y: 50,
      },
      stops: [
        {
          position: 0,
          color: '#c0ffee',
        },
        {
          position: 0.5,
          color: '#0ff1ce',
        },
        {
          position: 1,
          color: '#bada55',
        },
      ],
    },
  },
]

Style.GradientType.Radial

// Get the axes
const axes = textLayer.style.fontAxes

// If axes is non-null the Text Layer's font
// is a valid variable font recognised by Sketch
if (axes) {
  // Mutate the axes object, taking care
  // to work within the min and max range
  // specified for each axis
  axes.Weight.value = axes.Weight.max
  axes.Monospace.value = 1
  // Apply the new axes to update
  // the text layer
  textLayer.style.fontAxes = axes
}

var SharedStyle = require('sketch/dom').SharedStyle

document.sharedTextStyles.push({
  name: 'Header 1',
  style: text.style,
})

const newSharedStyle = SharedStyle.fromStyle({
  name: 'Header 1',
  style: layer.style,
  document: document,
})

// you can also push to the shared styles arrays directly
document.sharedTextStyles.push({
  name: 'Header 1',
  style: text.style,
})

var styles = sharedStyle.getAllInstances()

var layers = sharedStyle.getAllInstancesLayers()

var originLibrary = sharedStyle.getLibrary()

const success = sharedStyle.syncWithLibrary()

const success = sharedStyle.unlinkFromLibrary()

SharedStyle.StyleType.Text

var overrides = symbolInstance.overrides

var frame = override.getFrame()

var Flow = require('sketch/dom').Flow

layer.flow = {
  target: artboard,
}

layer.flow = {
  targetId: artboard.id,
}

layer.flow = {
  target: artboard,
  animationType: Flow.AnimationType.slideFromLeft,
}

layer.flow = {
  target: Flow.BackTarget,
}

layer.flow.isBackAction()

layer.flow.isValidConnection()

layer.flow = {
  target: Flow.BackTarget,
}

Flow.AnimationType.slideFromLeft

var selection = document.selectedLayers

selection.forEach(layer => log(layer.id))

selection.map(layer => layer.id)

selection.reduce((initial, layer) => {
  initial += layer.name
  return initial
}, '')

selection.clear()

var cgPoint = point.asCGPoint()

var nsPoint = rect.asNSPoint()

shape.points[0].isSelected()

var Rectangle = require('sketch/dom').Rectangle

var rect = new Rectangle(0, 0, 100, 100)

var rectFromAnotherRect = new Rectangle(rect)

var newRect = rect.offset(x, y)

var newRect = rect.scale(scaleWidth, scaleHeight)

var newRect = rect.changeBasis({
  from: layerA,
  to: layerB,
})

var parentRect = rect.changeBasis({
  from: layerA,
  to: layerA.parent,
})

var pageRect = rect.changeBasis({
  from: layerA,
  // leaving out `to` means changing the
  // basis to the Page's basis
})

var cgRect = rect.asCGRect()

var nsRect = rect.asNSRect()

var sketch = require('sketch/dom')
var document = sketch.fromNative(context.document)

var sketch = require('sketch/dom')
var colors = sketch.globalAssets.colors

var sketch = require('sketch/dom')
var gradients = sketch.globalAssets.gradients

var sketch = require('sketch')
var mySwatch = sketch.Swatch.from({
  name: 'Safety Orange',
  color: '#ff6600'
})
var myColor = mySwatch.referencingColor

const SmartLayout = require('sketch').SmartLayout
layer.smartLayout = SmartLayout.TopToBottom

symbol.smartLayout = null

const SmartLayout = require('sketch').SmartLayout
symbol.smartLayout = SmartLayout.TopToBottom
symbolInstance.resizeWithSmartLayout()

var duplicatedLayer = layer.duplicate()

layer.remove()

var index = layer.index

layer.index = 2

layer.moveToFront()

// which is the same as

layer.index = layer.parent.layers.length - 1

layer.moveForward()

// which is the same as

layer.index = layer.index + 1

layer.moveToBack()

// which is the same as

layer.index = 0

layer.moveBackward()

// which is the same as

layer.index = layer.index - 1

// access the page the layer is in
layer.getParentPage()
page.getParentPage() === undefined

// access the artboard the layer is in (if any)
layer.getParentArtboard()
artboard.getParentArtboard() === undefined

// access the Symbol Source the layer is in (if any)
layer.getParentSymbolMaster()
symbolMaster.getParentSymbolMaster() === undefined

// access the shape the layer is in (if any)
layer.getParentShape()

var Group = require('sketch/dom').Group

new Group()

var group = new Group({
  name: 'my name',
  layers: [
    {
      type: sketch.Types.Text,
      text: 'Hello world',
    },
  ],
})

group.adjustToFit()

var Page = require('sketch/dom').Page

new Page()

new Page({
  name: 'my page',
})

var selection = document.selectedLayers

var symbolsPage = Page.getSymbolsPage(document)

var symbolsPage = Page.createSymbolsPage()
symbolsPage.parent = document

var isSymbolsPage = page.isSymbolsPage()

var Artboard = require('sketch/dom').Artboard

new Artboard()

new Artboard({
  name: 'my name',
  flowStartPoint: true,
})

var Shape = require('sketch/dom').Shape

new Shape({
  name: 'my shape',
})

var Image = require('sketch/dom').Image

var imageLayer = new Image({
  image: 'path/to/image.png',
})

var imageLayer = new Image({
  image: 'path/to/image.png',
  frame: new Rectangle(0, 0, 300, 200),
})

var imageData = imageLayer.image

imageData.nsimage // return a native NSImage
imageData.nsdata // return a native NSData representation of the image

imageLayer.image.size // { width: 100, height: 100 }

var ShapePath = require('sketch/dom').ShapePath

const shapePath = new ShapePath({
  name: 'my shape path',
  shapeType: ShapePath.ShapeType.Oval,
})

const shapePath = ShapePath.fromSVGPath('M10 10 H 90 V 90 H 10 L 10 10')

const svgPath = shapePath.getSVGPath()

ShapePath.ShapeType.Oval

ShapePath.PointType.Undefined

var Text = require('sketch/dom').Text

var text = new Text({
  text: 'my text',
  alignment: Text.Alignment.center,
})

text.adjustToFit()

var fragments = text.fragments

Text.Alignment.center

Text.VerticalAlignment.center

Text.LineSpacing.constantBaseline

var SymbolMaster = require('sketch/dom').SymbolMaster

var symbol = new SymbolMaster({
  name: 'my symbol',
})

var symbol = SymbolMaster.fromArtboard(artboard)

var artboard = symbol.toArtboard()

var instance = symbol.createNewInstance()

var instances = symbol.getAllInstances()

var originLibrary = symbol.getLibrary()

const success = symbol.syncWithLibrary()

const success = symbol.unlinkFromLibrary()

var SymbolInstance = require('sketch/dom').SymbolInstance

var instance = new SymbolInstance({
  name: 'my symbol instance',
  symbolId: symbolId,
})

var instance = symbol.createNewInstance()

var group = instance.detach()

var group = instance.detach({
  recursively: true,
})

instance.setOverrideValue(instance.overrides[0], 'overridden')

instance.resizeWithSmartLayout()

var HotSpot = require('sketch/dom').HotSpot

new HotSpot()

new HotSpot({
  name: 'my name',
  flow: {
    target: artboard,
  },
})

var hotspot = HotSpot.fromLayer(layer)

var Slice = require('sketch/dom').Slice

UI.getInputFromUser(
  "What's your name?",
  {
    initialValue: 'Appleseed',
  },
  (err, value) => {
    if (err) {
      // most likely the user canceled the input
      return
    }
  }
)

UI.getInputFromUser(
  "What's your favorite design tool?",
  {
    type: UI.INPUT_TYPE.selection,
    possibleValues: ['Sketch', 'Paper'],
  },
  (err, value) => {
    if (err) {
      // most likely the user canceled the input
      return
    }
  }
)

var DataSupplier = require('sketch/data-supplier')

var DataSupplier = require('sketch/data-supplier')

// onStartup would be the handler for the `Startup` action defined in the manifest.json
export function onStartup() {
  DataSupplier.registerDataSupplier(
    'public.text',
    'My Custom Data',
    'SupplyKey'
  )
}

var util = require('util')
var sketch = require('sketch/dom')
var DataSupplier = require('sketch/data-supplier')

// onSupplyKeyNeeded would be the handler for
// the `SupplyKey` action defined in the manifest.json
export function onSupplyKeyNeeded(context) {
  var count = context.data.items.count()
  var key = context.data.key
  var items = context.data.items

  // you will often want to get wrapped objects instead
  // of the native ones supplied in the context
  var wrappedItems = util.toArray(items).map(sketch.fromNative)
}

var DataSupplier = require('sketch/data-supplier')

// onSupplyKeyNeeded would be the handler for
// the `SupplyKey` action defined in the manifest.json
export function onSupplyKeyNeeded(context) {
  var count = context.data.items.count()
  var key = context.data.key

  var data = Array.from(Array(count)).map(i => 'foo')

  DataSupplier.supplyData(key, data)
}

var util = require('util')
var sketch = require('sketch/dom')
var DataSupplier = require('sketch/data-supplier')

// onSupplyKeyNeeded would be the handler for
// the `SupplyKey` action defined in the manifest.json
export function onSupplyKeyNeeded(context) {
  var key = context.data.key
  var items = util.toArray(context.data.items).map(sketch.fromNative)

  items.forEach((item, i) => {
    // item is either a Layer or a DataOverride
    DataSupplier.supplyDataAtIndex(key, 'foo', i)
  })
}

var DataSupplier = require('sketch/data-supplier')

// onShutdown would be the handler for the `Shutdown` action defined in the manifest.json
export function onShutdown() {
  DataSupplier.deregisterDataSuppliers()
}

var fiber = require('sketch/async').createFiber()
longRunningTask(function(err, result) {
  fiber.cleanup()
  // you can continue working synchronously here
})

var sketch = require('sketch/dom')
sketch.export(layer, {
  formats: 'svg',
})

sketch.export([layer, layer2])

const options = { scales: '1, 2, 3', formats: 'png, jpg' }
sketch.export(page, options)

sketch.export(document.pages)

const options = { formats: 'json', output: false }
const sketchJSON = sketch.export(layer, options)

const options = { formats: 'png', output: false }
const buffer = sketch.export(layer, options)

var sketch = require('sketch/dom')

const layer = sketch.createLayerFromData(buffer, 'svg')

const svgString =
  '<svg width="200px" height="100px" viewBox="0 0 200 100" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><rect fill="#000000" x="0" y="0" width="200" height="100"></rect></svg>'

const group = sketch.createLayerFromData(svgString, 'svg')

var sketch = require('sketch/dom')
sketch.find('Shape')

// find all the Shapes in the current Document
sketch.find('Shape')

// find all the Layers in the first Page of the Document
sketch.find('*', document.pages[0])

// find all the Layers named "Layer-Name"
sketch.find('[name="Layer-Name"]')

// find all the Shape named "Layer-Name"
sketch.find('Shape, [name="Layer-Name"]')