var font = NSFont(name: "フォント名", size: 18.0)!
font = NSFontManager.shared.convertWeight(true, of: font)

import Foundation

extension URL {
    var fileName: String {
        return self.deletingPathExtension().lastPathComponent
    }
}

let url = URL(fileURLWithPath: "/Users/takuto/Desktop/EpG-3qSU8AAaU-x.jpg")
print(url.fileName)

EpG-3qSU8AAaU-x

let path = "x-apple.systempreferences:com.apple.preference.security?キー"
NSWorkspace.shared.open(URL(string: path)!)

import CoreBluetooth

if #available(OSX 10.15, *) {
    switch CBCentralManager.authorization {
    case .notDetermined:
        logput("未設定")
    case .restricted:
        logput("制限あり（どうしたらこうなるのか不明）")
    case .denied:
        logput("許可されていない（チェックが外れている）")
    case .allowedAlways:
        logput("許可されている（チェックがついている）")
    @unknown default:
        logput("default")
    }
}

func allowedScreenRecording() -> Bool {
    return CGWindowListCreateImage(
        CGRect(x: 0, y: 0, width: 1, height: 1),
        CGWindowListOption.optionOnScreenOnly,
        kCGNullWindowID,
        []
    ) != nil
}

# macだと勝手に発生するいらないファイル
.DS_Store
# Xcodeでプロジェクトを開いていた状態の記録（ソースを変更していなくても状態が変わるだけで差分が出てしまう）
*.xcuserstate  #

$ git rm -r --cached .

const path = require("path");
path.resolve(process.env.HOME);

override func awakeFromNib() {
    super.awakeFromNib()
    NSColor.ignoresAlpha = false
}

import Cocoa

extension NSTextField {
    open override func performKeyEquivalent(with event: NSEvent) -> Bool {
        let flags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
        if flags == [.command] {
            let selector: Selector
            switch event.charactersIgnoringModifiers?.lowercased() {
            case "x": selector = #selector(NSText.cut(_:))
            case "c": selector = #selector(NSText.copy(_:))
            case "v": selector = #selector(NSText.paste(_:))
            case "a": selector = #selector(NSText.selectAll(_:))
            case "z": selector = Selector(("undo:"))
            default: return super.performKeyEquivalent(with: event)
            }
            return NSApp.sendAction(selector, to: nil, from: self)
        } else if flags == [.shift, .command] {
            if event.charactersIgnoringModifiers?.lowercased() == "z" {
                return NSApp.sendAction(Selector(("redo:")), to: nil, from: self)
            }
            self.undoManager?.undo()
        }
        return super.performKeyEquivalent(with: event)
    }
}

func applicationDockMenu(_ sender: NSApplication) -> NSMenu? {
    // dock にメニューを追加できるよ
}

// ⭐️
// macOS 10.13以降
func application(_ application: NSApplication, open urls: [URL]) {
}

// ⭐️が実装されていると呼ばれない
// macOS 10.0以降
// applicationWillFinishLaunching(_:) より後にコールされる
// applicationDidFinishLaunching(_:) より前にコールされる
func application(_ sender: NSApplication, openFile filename: String) -> Bool {
}

// ⭐️が実装されていると呼ばれない
// macOS 10.3以降
func application(_ sender: NSApplication, openFiles filenames: [String]) {
}

imageView.imageScaling = .scaleProportionallyUpOrDown
imageView.imageAlignment = .alignCenter
imageView.image = NSImage()

imageView.wantsLayer = true
imageView.layer?.contentsGravity = CALayerContentsGravity.resizeAspect
imageView.layer?.contents = NSImage()

extension NSImage {
    var ppi: CGFloat {
        let rep = self.representations[0]
        return 72.0 * CGFloat(rep.pixelsWide) / self.size.width
    }
}

enum Gomi {
    case hoge
    case meu
}

let hoge = Gomi.hoge
print(String(describing: hoge))
print(String(reflecting: hoge))

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView(viewModel: ViewModel(model: MyModel()))
        }
    }
}

protocol Model {
    var value1: Int { get }

    var value2: Int { get set }

    mutating func method()
}

struct MyModel: Model {
    let value1: Int = 0

    var value2: Int = 0

    mutating func method() {
        value2 += 1
    }
}

@MainActor
class ViewModel: ObservableObject {
    @Published var model: Model
    
    var value1: Int {
        return model.value1
    }

    func method() {
        model.method()
    }
}

struct ContentView: View {
    @StateObject var viewModel: ViewModel

    var body: some View {
        Text("hello \(viewModel.value1)")
        SubView(viewModel).padding(16)
    }
}

struct SubView: View {
    @ObservedObject var viewModel: ViewModel

    init(_ viewModel: ViewModel) {
        self.viewModel = viewModel
    }

    var body: some View {
        Button("Push me") {
            viewModel.method()
        }
    }
}

func pretty(_ object: Any) {
    guard let data = try? JSONSerialization.data(withJSONObject: object, options: .prettyPrinted),
          let str = String(data: data, encoding: .utf8)
    else {
        Swift.print("Cannnot serialize the object.")
        return
    }
    Swift.print(str)
}

# Java
export JAVA_HOME="/Applications/Android Studio.app/Contents/jre/Contents/Home"

$ java -version
openjdk version "11.0.11" 2021-04-20
OpenJDK Runtime Environment (build 11.0.11+0-b60-7772763)
OpenJDK 64-Bit Server VM (build 11.0.11+0-b60-7772763, mixed mode)
$ 

import SwiftUI

struct SettingsView: View {
    private enum Tabs: Hashable {
        case general
        case format
    }

    var body: some View {
        TabView {
            GeneralSettingsView()
                .tabItem {
                    Label("general", systemImage: "gear")
                }
                .tag(Tabs.general)
            FormatSettingsView()
                .tabItem {
                    Label {
                        Text("format")
                    } icon: {
                         // copy は自作したSymbol (SVG)
-                       Image("copy")
+                       Image(nsImage: NSImage(named: "copy")!)
                    }
                }
                .tag(Tabs.format)
        }
        .padding(.horizontal, 40)
        .padding(.vertical, 20)
    }
}

swift build -c release --product [Product Name] --arch arm64 --arch x86_64

extension NSOutlineView {
    open override var allowsTypeSelect: Bool {
        get {  return false }
        set {}
    }
}

import SwiftUI

enum KeyType {
    case white
    case black
}

struct KeyShape: Shape {
    var keyType: KeyType

    func path(in rect: CGRect) -> Path {
        let w = rect.size.width
        let h = rect.size.height
        let r = w / 6.0
        let d = w / (keyType == .white ? 20.0 : 10.0)
        let l: CGFloat = (keyType == .white ? 1.0 : 0.6)
        var path = Path()
        path.move(to: CGPoint(x: d, y: 0))
        path.addLine(to: CGPoint(x: w - d, y: 0))
        path.addLine(to: CGPoint(x: w - d, y: l * h - r))
        path.addArc(center: CGPoint(x: w - d - r, y: l * h - r),
                    radius: r,
                    startAngle: Angle(degrees: 0),
                    endAngle: Angle(degrees: 90),
                    clockwise: false)
        path.addLine(to: CGPoint(x: d + r, y: l * h))
        path.addArc(center: CGPoint(x: d + r, y: l * h - r),
                    radius: r,
                    startAngle: Angle(degrees: 90),
                    endAngle: Angle(degrees: 180),
                    clockwise: false)
        path.addLine(to: CGPoint(x: d, y: 0))
        path.closeSubpath()
        return path
    }
}

struct KeyboardView<KVM: KeyboardViewModel>: View {
    var body: some View {
        ZStack(alignment: .top) {
            // White Keys
            HStack(spacing: 0) {
                ForEach(0 ..< 15, id: \.self) { _ in
                    KeyShape(keyType: .white)
                        .fill(Color.white)
                        .aspectRatio(0.14, contentMode: .fit)
                }
            }
            // Black Keys
            HStack(spacing: 0) {
                ForEach(0 ..< 14, id: \.self) { i in
                    KeyShape(keyType: .black)
                        .fill(Color.black)
                        .aspectRatio(0.14, contentMode: .fit)
                        .opacity(i % 7 == 2 || i % 7 == 6 ? 0.0 : 1.0)
                }
            }
        }
    }
}

if let screen = NSScreen.main {
    let height = screen.frame.height - screen.visibleFrame.height
}

func cat(_ date: Date, _ size: CGFloat) -> some View {
    Group {
        Group {
            Text(date, style: .timer)
                .font(.custom("RunningCat-Regular", size: size))
                .lineLimit(1)
                .truncationMode(.head)
                .frame(width: 1.8 * size)
                .contentTransition(.identity)
        }
    }
    .frame(width: 1.74 * size,
           height: 0.55 * size,
           alignment: .leadingFirstTextBaseline)
    .clipped()
    .frame(width: 0.87 * size, alignment: .trailing)
    .clipped()
}

// containerURL はZipしたいフォルダ
let coordinator = NSFileCoordinator()
var error: NSError?
var zipURL: URL?
coordinator.coordinate(readingItemAt: containerURL, options: .forUploading, error: &error) {
    do {
        let tmpURL = containerURL.appendingPathExtension(for: .zip)
        try FileManager.default.moveItem(at: $0, to: tmpURL)
        zipURL = tmpURL
    } catch {
        logput(error.localizedDescription)
    }
}
guard error == nil, let zipURL else { throw CocoaError(.fileNoSuchFile) }

import SwiftUI

struct ContentView: View {
    @State var selection = Set<Int>()
    @State var items = [UUID]()

    var body: some View {
        VStack {
            List(selection: $selection) {
                ForEach(items.indices, id: \.self) { index in
                    Text(items[index].uuidString).tag(index)
                }
            }
            Button {
                items.append(UUID())
            } label: {
                Image(systemName: "plus")
            }
            Button {
                items.remove(atOffsets: IndexSet(selection))
                selection.removeAll()
            } label: {
                Image(systemName: "minus")
            }
        }
        .onAppear {
            items = (0 ..< 50).map { _ in UUID() }
        }
    }
}

$ sudo rm /var/db/timed/com.apple.timed.plist
$ sudo sntp -S ntp.nict.jp
$ ps -ef | grep timed
  266   138     1   0  3:42PM ??         0:00.18 /usr/libexec/timed
$ sudo kill 138
$ sudo sntp -S ntp.nict.jp