let imageViewGuide = UILayoutGuide()
collectionView.addLayoutGuide(imageViewGuide)
NSLayoutConstraint.on([
    imageViewGuide.topAnchor.constraint(equalTo: collectionView.topAnchor, constant: 16),
    imageViewGuide.heightAnchor.constraint(equalTo: collectionView.heightAnchor, multiplier: 0.5)
])

NSLayoutConstraint.on([
    loadingIndicator.centerXAnchor.constraint(equalTo: collectionView.centerXAnchor),
    loadingIndicator.centerYAnchor.constraint(equalTo: imageViewGuide.centerYAnchor)
])

private func maskCvcIfAny() {
    guard
        let view = paymentTextField.subviews.first(where: { !($0 is UIImageView) }),
        let cvcField = view.subviews
			.compactMap({ $0 as? UITextField })
			.first(where: { $0.tag == 2 && ($0.accessibilityLabel ?? "").lowercased().contains("cvc")  })
    else {
        return
    }
  
    cvcField.isSecureTextEntry = true
}

<RadioGroup 
	style={styles.group} 
    defaultselected={this.state.choice} 
    onChange={this.handleChoiceChange}
    children={choiceElements} />
    {this.makeGenerateButton()}
/>

public func resolve<T>(_ jsonDictionary: [String: Any], keyPath: String) -> T? {
    var current: Any? = jsonDictionary

    keyPath.split(separator: ".").forEach { component in
        if let maybeInt = Int(component), let array = current as? Array<Any> {
            current = array[maybeInt]
        } else if let dictionary = current as? JSONDictionary {
            current = dictionary[String(component)]
        }
    }

    return current as? T
}

class JSONTests: XCTestCase {
    func test() {
        let json: [String: Any] = [
            "outside": [
                "object": [
                    "number": 1,
                    "text": "hello"
                ],
                "arrayOfObjects": [
                    [
                        "number": 2,
                        "text": "two"
                    ],
                    [
                        "number": 3,
                        "text": "three"
                    ]
                ],
                "arrayOfArrays": [
                    [
                        "one", "two", "three", "four"
                    ],
                    [
                        "five", "six", "seven"
                    ]
                ]
            ]
        ]

        XCTAssertEqual(resolve(json, keyPath: "outside.object.number"), 1)
        XCTAssertEqual(resolve(json, keyPath: "outside.object.text"), "hello")
        XCTAssertEqual(resolve(json, keyPath: "outside.arrayOfObjects.1.number"), 3)
        XCTAssertEqual(resolve(json, keyPath: "outside.arrayOfArrays.1.1"), "six")
    }
}

isOpaque = true
layer.shouldRasterize = true
layer.rasterizationScale = UIScreen.main.scale

final class StopMarker: GMSMarker {
    let stop: Stop
    private let pinView = PinView()

    init(stop: Stop) {
        self.stop = stop
        super.init()
        self.position = stop.toCoordinate()
        self.iconView = pinView
    }
}

class ViewController: UIViewController, UICollectionViewDropDelegate, UICollectionViewDragDelegate {

    // MARK: - UICollectionViewDragDelegate

    func collectionView(_ collectionView: UICollectionView, itemsForBeginning session: UIDragSession, at indexPath: IndexPath) -> [UIDragItem] {
        let controller = leftController

        let provider = NSItemProvider(
            object: controller.imageForCell(indexPath: indexPath)
        )

        let dragItem = UIDragItem(itemProvider: provider)
        dragItem.localObject = indexPath
        return [dragItem]
    }

    // MARK: - UICollectionViewDropDelegate

    func collectionView(_ collectionView: UICollectionView, performDropWith coordinator: UICollectionViewDropCoordinator) {

        let destinationIndexPath: IndexPath
        if let indexPath = coordinator.destinationIndexPath {
            destinationIndexPath = indexPath
        } else {
            destinationIndexPath = IndexPath(row: 0, section: 0)
        }

        let controller = rightController

        let dragItemIndexPath = coordinator.items.last?.dragItem.localObject as! IndexPath
        let draggedItem = leftController.items[dragItemIndexPath.item]

        // remove
        leftController.items.remove(at: dragItemIndexPath.item)
        leftController.collectionView.deleteItems(at: [dragItemIndexPath])

        // insert
        controller.items.insert(draggedItem, at: destinationIndexPath.item)
        controller.collectionView.insertItems(at: [destinationIndexPath])
    }
}

import AppKit
import Anchors

class DraggingView: NSView {
    var didDrag: ((FileInfo) -> Void)?
    let highlightView = NSView()

    override init(frame frameRect: NSRect) {
        super.init(frame: frameRect)

        registerForDraggedTypes([
            .fileURL
        ])

        highlightView.isHidden = true
        addSubview(highlightView)
        activate(highlightView.anchor.edges)
        highlightView.wantsLayer = true
        highlightView.layer?.borderColor = NSColor(hex: "#FF6CA8").cgColor
        highlightView.layer?.borderWidth = 6
    }

    required init?(coder decoder: NSCoder) {
        fatalError()
    }

    override func draggingEntered(_ sender: NSDraggingInfo) -> NSDragOperation {
        highlightView.isHidden = false
        return NSDragOperation()
    }

    override func draggingEnded(_ sender: NSDraggingInfo) {
        guard let pathAlias = sender.draggingPasteboard.propertyList(forType: .fileURL) as? String else {
            return
        }

        let url = URL(fileURLWithPath: pathAlias).standardized
        let fileInfo = FileInfo(url: url)
        didDrag?(fileInfo)
    }

    override func draggingExited(_ sender: NSDraggingInfo?) {
        highlightView.isHidden = true
    }

    override func draggingUpdated(_ sender: NSDraggingInfo) -> NSDragOperation {
        return NSDragOperation()
    }
}

override func draggingEnded(_ sender: NSDraggingInfo) {
    guard let pasteBoardItems = sender.draggingPasteboard.pasteboardItems else {
        return
    }

    let fileInfos: [FileInfo] = pasteBoardItems
        .compactMap({
            return $0.propertyList(forType: .fileURL) as? String
        })
        .map({
            let url = URL(fileURLWithPath: $0).standardized
            return FileInfo(url: url)
        })

    didDrag(fileInfos)
}

let stepper = NSStepper()
let textField = NSTextField(wrappingLabelWithString: "\(myLocalCount)")

stepper.integerValue = myLocalCount
stepper.minValue = 5
stepper.maxValue = 24
stepper.valueWraps = false

stepper.target = self
stepper.action = #selector(onStepperChange(_:))

@objc func onStepperChange(_ sender: NSStepper) {
    myLocalCount = sender.integerValue
    textField.stringValue = "\(sender.integerValue)"
}

let shortcut = MASShortcut(keyCode: kVK_ANSI_K, modifierFlags: [.command, .shift])

MASShortcutMonitor.shared()?.register(shortcut, withAction: {
    self.showPopover(sender: self.statusItem.button)
})

NSWorkspace.shared.selectFile(
    url.path,
    inFileViewerRootedAtPath: url.deletingLastPathComponent().path)

let progressIndicator = NSProgressIndicator()
progressIndicator.isIndeterminate = true
progressIndicator.style = .spinning
progressIndicator.startAnimation(nil)

func save() {
    let panel = NSSavePanel()
    // 3
    panel.directoryURL = FileManager.default.homeDirectoryForCurrentUser
    // 4
    panel.nameFieldStringValue = "abc.gif"

    // 5
    guard let window = view.window else {
        return
    }

    panel.beginSheetModal(for: window) { (result) in
        guard result == .OK, let url = panel.url else {
            self.showAlert()
            return
        }
    }
}

func showAlert() {
    let alert = NSAlert()
    alert.messageText = "Hello world"
    alert.informativeText = "Information text"
    alert.addButton(withTitle: "OK")
    alert.addButton(withTitle: "Cancel")
    alert.runModal()
}

let panel = NSOpenPanel()
panel.canChooseFiles = false
panel.allowsMultipleSelection = false
panel.canChooseDirectories = true
panel.directoryURL = FileManager.default.homeDirectoryForCurrentUser

let animation = CAKeyframeAnimation(keyPath: "position.y")
animation.values = [50, 20, 50]
animation.keyTimes = [0.0, 0.5, 1.0]
animation.duration = 2
animation.repeatCount = Float.greatestFiniteMagnitude
animation.autoreverses = true
myView.wantsLayer = true
myView.layer?.add(animation, forKey: "bounce")

func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
    return true
}

let base =  Date(timeIntervalSince1970: 1567756697)
XCTAssertEqual(validator.hasPassed(event: event, date: base), true)

func minuteSinceMidnight(date: Date) -> MinuteSinceMidnight {
    let calendar = Calendar.current
    let start = calendar.startOfDay(for: date)
    return Int(date.timeIntervalSince(start)) / 60
}

func minuteSinceMidnight(date: Date) -> MinuteSinceMidnight {
    let components = calendar.dateComponents([.hour, .minute], from: date)
    guard let hour = components.hour, let minute = components.minute else {
        return 0
    }

    return hour * 60 + minute
}

let formatter = ISO8601DateFormatter()
let date = formatter.date(from: "2019-07-58T12:39:00Z")
let string = formatter.string(from: Date())

var calendar = Calendar.current
calendar.timeZone = TimeZone(secondsFromGMT: 0)!

calendar.date(bySettingHour: 20, minute: 02, second: 00, of: Date()

import Foundation
import Firebase
import FirebaseAnalytics

struct Analytics {
    enum Parameter: String {
        case studentId = "student_id"
        case classId = "class_id"
        case url = "url"
    }

    enum Property: String {
        case grantLocation = "grant_location"
    }

    enum Name: String {
        case login
        case logOut = "log_out"
        case enroll
    }

    struct Log {
        private func log(_ name: Name, parameters: [Parameter: String] = [:]) {
            let mapped: [String: String] = Dictionary(uniqueKeysWithValues: parameters.map({ key, value in
                return (key.rawValue, value)
            }))

            FirebaseAnalytics.Analytics.logEvent(name.rawValue, parameters: mapped)
        }

        private func set(userId: String?) {
            FirebaseAnalytics.Analytics.setUserID(userId)
        }

        private func setProperty(_ property: Property, value: String) {
            FirebaseAnalytics.Analytics.setUserProperty(value, forName: property.rawValue)
        }
    }

    let log = Log()
}

extension Analytics.Log {
    func grantLocation(hasGranted: Bool) {
        setProperty(.grantLocation, value: hasGranted.toString())
    }

    func login(userId: String) {
        log(.login)
        set(userId: userId)
    }

    func logOut() {
        log(.logOut)
        set(userId: nil)
    }

    func enroll(classId: String) {
        log(.enroll, parameters: [
            .classId: classId
        ])
    }
}

private extension Bool {
    func toString() -> String {
        return self ? "yes": "no"
    }
}