npm install esm

const fs = require('fs');
// intended to be run after babel, and in ./dist folder
import factory from 'data'
const shell = require('shelljs')

{
  "name": "generator",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "npx babel index.js --out-file dist/index.js && node -r esm dist/index.js"
  }
}

{
    "name": "data",
    "version": "0.1.0",
    "private": true,
    "homepage": ".",
    "main": "main.js"
}

{
  "name": "landing",
  "version": "0.1.0",
  "private": true,
  "homepage": ".",
  "dependencies": {
    "@emotion/core": "^10.0.28",
    "react": "^16.13.1",
    "react-dom": "^16.13.1",
    "react-image": "^2.4.0",
    "react-scripts": "3.4.1",
    "data": "file:../data"
  },

const shell = require('shelljs')
shell.exec(`cp -a source_path/. destination_path`)

.replace(/\"/g, '')
.replace(/\"/g, '')

const fs = require('fs')

const originalFile = 'MyApp/Resources/nb.lproj/Localizable.strings'
const translationString = `
"open" = "Åpen";
"closed" = "Stengt";
`

class Translation {
    constructor(key, value) {
        this.key = key
        this.value = value
    }
}

Translation.make = function make(line) {
    if (!line.endsWith(';')) {
        return new Translation('', '')
    }

    const parts = line
        .replace(';')
        .split(" = ")

    const key = parts[0]
        .replace(/\"/g, '')
        .replace(/\”/g, '')
    const value = parts[1]
        .replace(/\"/g, '')
        .replace(/\”/g, '')
        .replace('undefined', '')
    return new Translation(key, value)
}

function main() {
    const translations = translationString
        .split(/\r?\n/)
        .map((line) => { return Translation.make(line) })

    apply(translations, originalFile)
}

function apply(translations, originalFile) {
    try {
        const originalData = fs.readFileSync(originalFile, 'utf8')
        const originalLines = originalData.split(/\r?\n/)
        const parsedLine = originalLines.map((originalLine) => {
            const originalTranslation = Translation.make(originalLine)
            const find = translations.find((translation) => { return translation.key === originalTranslation.key })
            if (originalLine !== "" && find !== undefined &&  find.key !== "") {
                return `"${find.key}" = "${find.value}";`
            } else {
                return originalLine
            }
        })

        const parsedData = parsedLine.join('\n')
        fs.writeFileSync(originalFile, parsedData, { overwrite: true })
    } catch (err) {
        console.error(err)
    }
}

main()

{
  "name": "icon_generator",
  "version": "1.3.0",
  "description": "A macOS app to generate app icons",
  "main": "babel/main.js",
  "repository": "https://github.com/onmyway133/IconGenerator",
  "author": "Khoa Pham",
  "license": "MIT",
  "scripts": {
    "start": "npm run babel && electron .",
    "babel": "babel ./src --out-dir ./babel --copy-files",
    "dist": "npm run babel && electron-builder"
  },
  "build": {
    "appId": "com.onmyway133.IconGenerator",
    "buildVersion": "20",
    "productName": "Icon Generator",
    "icon": "./Icon/Icon.icns",
    "mac": {
      "category": "public.app-category.productivity",
      "hardenedRuntime": true,
      "gatekeeperAssess": false,
      "entitlements": "./entitlements.plist",
      "entitlementsInherit": "./entitlements.plist"
    },
    "win": {
      "target": "msi"
    },
    "linux": {
      "target": [
        "AppImage",
        "deb"
      ]
    },
    "afterSign": "./afterSignHook.js"
  }
}

const fs = require('fs');
const path = require('path');
var electron_notarize = require('electron-notarize');

module.exports = async function (params) {
    // Only notarize the app on Mac OS only.
    if (process.platform !== 'darwin') {
        return;
    }
    console.log('afterSign hook triggered', params);

    // Same appId in electron-builder.
    let appId = 'com.onmyway133.IconGenerator'

    let appPath = path.join(params.appOutDir, `${params.packager.appInfo.productFilename}.app`);
    if (!fs.existsSync(appPath)) {
        throw new Error(`Cannot find application at: ${appPath}`);
    }

    console.log(`Notarizing ${appId} found at ${appPath}`);

    try {
        await electron_notarize.notarize({
            appBundleId: appId,
            appPath: appPath,
            appleId: process.env.appleId,
            appleIdPassword: process.env.appleIdPassword,
        });
    } catch (error) {
        console.error(error);
    }

    console.log(`Done notarizing ${appId}`);
};

function write(json) {
    const data = JSON.stringify(json)
    const year = json.date.getFullYear()
    const directory = `collected/${slugify(className)}/${year}`

    fs.mkdirSync(directory, { recursive: true })
    fs.writeFileSync(
        `${directory}/${slugify(studentName)}`, 
        data,
        { overwrite: true }
    )
}

async function readAll() {
    const classes = fs.readdirSync('classes')
    classes.forEach((class) => {
        const years = fs.readdirSync(`classes/${class}`)
        years.forEach((year) => {
            const students = fs.readdirSync(`classes/${class}/${year}`)
            students.forEach((student) => {
            	const data = fs.readFileSync(`classes/${class}/${year}/${student})
            	const json = JSON.parse(data)
            })
        })
    })
}

const Vimeo = require('vimeo').Vimeo
const vimeoClient = new Vimeo(vimeoClientId, vimeoClientSecret, vimeoAccessToken)

async getVideos(path) {
    const options = {
        path: `channels/staffpicks/videos`,
        query: {
            page: 1,
            per_page: 100,
            fields: 'uri,name,description,created_time,pictures'
          }
    }

    return new Promise((resolve, reject) => {
        try {
            vimeoClient.request(options, (error, body, status_code, headers) => {
                if (isValid(body)) {
                    resolve(body)
                } else {
                    throw error
                }
            })
        } catch (e) {
            reject(e)
            console.log(e)
        }
    })
}

class Youtube {
    async getVideos(playlistId, pageToken) {
        const options = {
            key: clientKey,
            part: 'id,contentDetails,snippet',
            playlistId: playlistId,
            maxResult: 100, 
            pageToken
        }

        return new Promise((resolve, reject) => {
            try {
                youtube.playlistItems.list(options, (error, result) => {
                    if (isValid(result)) {
                        resolve(result)
                    } else {
                        throw error
                    }
                })
            } catch (e) {
                reject(e)
            }
        })
    }
}

{
 "kind": "youtube#playlistItemListResponse",
 "etag": "\"p4VTdlkQv3HQeTEaXgvLePAydmU/ZNTrH71d3sV6gR6BWPeamXI1HhE\"",
 "nextPageToken": "CAUQAA",
 "pageInfo": {
  "totalResults": 32,
  "resultsPerPage": 5
 },
 "items": [
  {
   "kind": "youtube#playlistItem",
   "etag": "\"p4VTdlkQv3HQeTEaXgvLePAydmU/pt-bElhU3f7Q6c1Wc0URk9GJN-w\"",
   "id": "UExDbDVOTTRxRDN1X0w4ZEpyV1liTEI4RmNVYW9BSERGdC4yODlGNEE0NkRGMEEzMEQy",
   "snippet": {
    "publishedAt": "2019-04-11T06:09:26.000Z",
    "channelId": "UCuPue-GLK4nVX8klxQITIOw",
    "title": "abc",
    "description": "abc",
    "thumbnails": {
     "default": {
      "url": "https://i.ytimg.com/vi/ZefmzgLabCA/default.jpg",
      "width": 120,
      "height": 90
     },
     "medium": {
      "url": "https://i.ytimg.com/vi/ZefmzgLabCA/mqdefault.jpg",
      "width": 320,
      "height": 180
     },
     "high": {
      "url": "https://i.ytimg.com/vi/ZefmzgLabCA/hqdefault.jpg",
      "width": 480,
      "height": 360
     },
     "standard": {
      "url": "https://i.ytimg.com/vi/ZefmzgLabCA/sddefault.jpg",
      "width": 640,
      "height": 480
     },
     "maxres": {
      "url": "https://i.ytimg.com/vi/ZefmzgLabCA/maxresdefault.jpg",
      "width": 1280,
      "height": 720
     }
    },
    "channelTitle": "try! Swift Conference",
    "playlistId": "PLCl5NM4qD3u_L8dJrWYbLB8FcUaoAHDFt",
    "position": 0,
    "resourceId": {
     "kind": "youtube#video",
     "videoId": "ZefmzgLabCA"
    }
   }
  }
 ]
}

async getVideosLoop(playlistId, nextPageToken, items, count) {
    const response = await this.getVideos(playlistId, nextPageToken)
    const newItems = items.concat(response.data.items)
    if (isValid(response.data.nextPageToken) && count < 10) {
        return this.getVideosLoop(playlistId, response.data.nextPageToken, newItems, count + 1)
    } else {
        return newItems
    }
}

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';
import Main from './Main'

class App extends Component {
  render() {
    return <Main />
  }
}

export default App;

// @flow

import React from 'react';
import PropTypes from 'prop-types';
import { withStyles } from '@material-ui/core/styles';
import AppBar from '@material-ui/core/AppBar';
import Toolbar from '@material-ui/core/Toolbar';
import Typography from '@material-ui/core/Typography';
import Button from '@material-ui/core/Button';
import IconButton from '@material-ui/core/IconButton';
import MenuIcon from '@material-ui/icons/Menu';

import Manager from './Manager'

const styles = {
    root: {
      flexGrow: 1,
    },
    grow: {
      flexGrow: 1,
    },
    menuButton: {
      marginLeft: -12,
      marginRight: 20,
    },
};

class Main extends React.Component {
    static propTypes = {
        classes: PropTypes.object.isRequired,
    }

    render() {
        const { classes } = this.props;

        return (
            <div className={classes.root}>
              <AppBar position="static">
                <Toolbar>
                  <IconButton className={classes.menuButton} color="inherit" aria-label="Menu">
                    <MenuIcon />
                  </IconButton>
                  <Typography variant="h6" color="inherit" className={classes.grow}>
                    Collaborate Canvas
                  </Typography>
                  <Button color="inherit" onClick={this.onImagePress} >Image</Button>
                  <Button color="inherit" onClick={this.onClearPress} >Clear</Button>
                  <input ref="fileInput" type="file" id="myFile" multiple accept="image/*" style={{display: 'none'}} onChange={this.handleFiles}></input>
                </Toolbar>
              </AppBar>
              <canvas ref="canvas" with="1000" height="1000"></canvas>
            </div>
        )
    }

    componentDidMount() {
      const canvas = this.refs.canvas
      this.manager = new Manager(canvas)
      this.manager.connect()
    }

    onImagePress = () => {
      const fileInput = this.refs.fileInput
      fileInput.click()
    }

    onClearPress = () => {
      this.manager.clear()
    }

    handleFiles = (e) => {
      e.persist()
      const canvas = this.refs.canvas
      const context = canvas.getContext('2d')

      const file = e.target.files[0]
      var image = new Image()
      image.onload = function() {
          context.drawImage(image, 0, 0, window.innerWidth, window.innerHeight)
      }
      image.src = URL.createObjectURL(file)
    }
}

export default withStyles(styles)(Main);

// @flow

const express = require('express')
const app = express()
const http = require('http')
const socketIO = require('socket.io')

const server = http.createServer(app)
const io = socketIO.listen(server)
server.listen(3001)
app.use(express.static(__dirname + '/public'))
console.log("Server running on 127.0.0.1:8080")

let lines = []
io.on('connection', (socket) => {
    lines.forEach((line) => {
        const data = { line }
        socket.emit('draw_line', data) 
    })

    socket.on('draw_line', (data) => {
        const { line } = data
        lines.push(line)

        io.emit('draw_line', data)
    })

    socket.on('clear', () => {
        lines = []
        io.emit('clear')
    })

    socket.on('draw_image', (data) => {
        io.emit('draw_image', data)
    })
})

const Rx = require('rxjs/Rx')
const Fetch = require('node-fetch')
const Minimist = require('minimist')
const Fs = require('fs')

makeOptions(query, token) {
  return {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `bearer ${token}`
    },
    body: JSON.stringify({
      query: `
      query {
        repository(owner: "${this.owner}", name: "${this.repo}") {
          ${query}
        }
      }
      `
    })
  }
}

fetchPRsAndIssues(dates) {
    const query = `
    pullRequests(last: 100, orderBy: {field: UPDATED_AT, direction: ASC}) {
      edges {
        node {
          title
          merged
          mergedAt
          url
          author {
            login
            url
          }
        }
      }
    }
    issues(last: 100, orderBy: {field: UPDATED_AT, direction: ASC}) {
      edges {
        node {
          title
          closed
          updatedAt
          url
        }
      }
    }
  }
}

const Glob = require('glob')
const Fs = require('fs')

function main() {
  const projectPath = getProjectPath()
  const files = getAllFiles(projectPath)

  files.forEach((file) => {
    handleFile(file)
  })
}

/// The 1st argument is node, 2nd is index.js, 3rd is path
function getProjectPath() {
  return process.argv[2]
}

/// Only select `swift` file
function getAllFiles(projectPath) {
  if (projectPath.endsWith('.swift')) {
    return [projectPath]
  } else {
    const files = Glob.sync(`${projectPath}/**/*.swift`)
    return files
  }
}

/// Read file, replace by matches, and write again
function handleFile(file) {
  console.log(file)

  Fs.readFile(file, 'utf8', (error, data) => {
    // non greedy `*?`
    const pattern = '(.)*constrain\\(.+\\) {\\s(\\s|.)*?\\n(\\s)*}'
    const regex = new RegExp(pattern)
    
    let matches = data.match(regex)

    // RegEx only return the 1st match per execution, let's do a recursion
    while (matches != null) {
      const match = matches[0]

      const indentationLength = findIndentationLength(match)
      const rawTransforms = handleMatch(match)
      const transforms = handleSuperview(rawTransforms, match)
      const statements = handleTransforms(transforms, indentationLength)
      const string = handleStatements(statements, indentationLength)
      data = data.replace(match, string)

      // Examine again
      matches = data.match(regex)
    }

    // Handle import
    data = handleImport(data)


    Fs.writeFile(file, data, 'utf8')
  })
}

/// Replace or remove import
function handleImport(data) {
  if (data.includes('import Sugar')) {
    return data.replace('import Cartography', '')
  } else {
    return data.replace('import Cartography', 'import Sugar')
  }
}

/// Format transform to have `,` and linebreaks
function handleTransforms(transforms, indentationLength) {
  let string = ''

  // Expect the first is always line break
  if (transforms[0] != '\n') {
    transforms.unshift('\n')
  }

  const indentation = makeIndentation(indentationLength + 2)
  
  transforms.forEach((line, index) => {
    if (line.length > 1) {
      string = string.concat(indentation + line)
      if (index < transforms.length - 1) {
        string = string.concat(',\n')
      }
    } else {
      string = string.concat('\n')
    }    
  })

  return string
}

/// Replace superView
function handleSuperview(transforms, match) {
  const superView = findSuperview(match)
  if (superView == null) {
    return transforms
  }

  const superViewPattern = ' superView.'
  transforms = transforms.map((transform) => {
    if (transform.includes(superViewPattern)) {
      return transform.replace(superViewPattern, ` ${superView}.`)
    } else {
      return transform
    }
  })

  return transforms
}

/// Embed the statements inside `Constraint.on`
function handleStatements(statements, indentationLength) {
  const indentation = makeIndentation(indentationLength)
  return `${indentation}Constraint.on(${statements}\n${indentation})`
}

/// Turn every line into flatten transformed line
function handleMatch(match) {
  let lines = match.split('\n')
  lines = lines.map((line) => {
    return handleLine(line.trim())
  }).filter((transforms) => {
    return transforms != null
  })

  let flatten = [].concat.apply([], lines)
  return flatten
}

/// Check to handle lines, turn them into `LayoutAnchor` statements
function handleLine(line) {
  const itemPattern = '\\w*\\.\\w* (=|<|>)= \\w*\\.*\\..*'
  const sizePattern = '\w*\.\w* (=|<|>)= (\s|.)*'

  if (line.includes('edges == ')) {
    return handleEdges(line)
  } else if (line.includes('center == ')) {
    return handleCenter(line) 
  } else if (hasPattern(line, itemPattern) && !hasSizeKeywords(line)) {
    return handleItem(line)
  } else if (hasPattern(line, sizePattern)) {
    return handleSize(line)
  } else if (line.includes('>=') || line.includes('>=')) {
    return line
  } else if (line.includes('.')) {
    // return the line itself to let the human fix
    return line
  } else if (line.length == 0) {
    return ['\n']
  } else {
    return null
  }
}

/// For ex: listView.bottom == listView.superview!.bottom - 43
/// listView.bottom == listView.superview!.bottom - Metrics.BackButtonWidth
function handleItem(line) {
  const equalSign = getEqualSign(line)
  const parts = line.split(` ${equalSign} `)
  const left = parts[0]

  let rightParts = parts[1].trim()
  let right = rightParts.split(' ')[0]
  let number = rightParts.replace(right, '').replace('- ', '-').trim()
  if (number.startsWith('+ ')) {
    number = number.slice(2)
  }
  
  let equal = getEqual(line)

  if (number == null || number.length == 0 ) {
    return [
      `${left}Anchor.constraint(${equal}: ${right}Anchor)`
    ]
  } else {
    return [
      `${left}Anchor.constraint(${equal}: ${right}Anchor, constant: ${number})`
    ]
  }
}

/// For ex: segmentedControl.height == 24
/// backButton.width == Metrics.BackButtonWidth
function handleSize(line) {
  const equalSign = getEqualSign(line)
  const parts = line.split(` ${equalSign} `)
  const left = parts[0]
  const right = parts[1]

  let equal = getEqual(line)

  return [
    `${left}Anchor.constraint(${equal}Constant: ${right})`
  ]
}

/// For ex: mapView.edges == listView.edges
function handleEdges(line) {
  const parts = line.split(' == ')
  const left = parts[0].split('.')[0]
  const right = removeLastPart(parts[1])

  return [
    `${left}.topAnchor.constraint(equalTo: ${right}.topAnchor)`,
    `${left}.bottomAnchor.constraint(equalTo: ${right}.bottomAnchor)`,
    `${left}.leftAnchor.constraint(equalTo: ${right}.leftAnchor)`,
    `${left}.rightAnchor.constraint(equalTo: ${right}.rightAnchor)`
  ]
}

/// For ex: mapView.center == listView.center
function handleCenter(line) {
  const parts = line.split(' == ')
  const left = parts[0].split('.')[0]
  const right = removeLastPart(parts[1])
  
  return [
    `${left}.centerXAnchor.constraint(equalTo: ${right}.centerXAnchor)`,
    `${left}.centerYAnchor.constraint(equalTo: ${right}.centerYAnchor)`
  ]
}

function hasPattern(string, pattern) {
  const regex = new RegExp(pattern)
  let matches = string.match(regex)

  if (matches == null) {
    return false
  }

  matches = matches.filter((match) => {
    return match !== undefined && match.length > 1
  })

  return matches.length > 0
}

function removeLastPart(string) {
  const parts = string.split('.')
  parts.pop()

  return parts.join('.')
}

function getEqual(line) {
  if (line.includes('==')) {
    return 'equalTo'
  } else if (line.includes('<=')) {
    return 'lessThanOrEqualTo'
  } else {
    return 'greaterThanOrEqualTo'
  }
}

function getEqualSign(line) {
  if (line.includes('==')) {
    return '=='
  } else if (line.includes('>=')) {
    return '>='
  } else {
    return '<='
  }
}

function findIndentationLength(match) {
  return match.split('constrain')[0].length + 1
}

function makeIndentation(length) {
  return Array(length).join(' ')
}

// For ex: constrain(tableView, headerView, view) { tableView, headerView, superView in
function findSuperview(match) {
  const line = match.split('\n')[0]
  if (!line.includes(' superView in')) {
    return null
  }

  const pattern = ', \\w*\\)'
  const regex = RegExp(pattern)
  const string =  line.match(regex)[0] // `, view)

  return string.replace(', ', '').replace(')', '')
}

// Check special size keywords
function hasSizeKeywords(line) {
  const keywords = ['Metrics', 'Dimensions', 'UIScreen']
  return keywords.filter((keyword) => {
    return line.includes(keyword)
  }).length != 0
}

main()