ETLane 0.1.42 → 0.1.46

data/Scripts/Sources/Common/Array.swift

@@ -0,0 +1,8 @@
+public extension Array where Element: Equatable {
+
+	/// Remove Dublicates
+	var unique: [Element] {
+		// Thanks to https://github.com/sairamkotha for improving the method
+		return self.reduce([]) { $0.contains($1) ? $0 : $0 + [$1] }
+	}
+}

data/Scripts/Sources/Common/Error.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+public extension Error {
+
+	var locd: String {
+		return "\(self.localizedDescription) - \(self)"
+	}
+
+}
+

data/Scripts/Sources/Common/MD5.swift

@@ -0,0 +1,34 @@
+import CommonCrypto
+import Foundation
+
+public extension String {
+
+	var MD5: Data {
+		let messageData = self.data(using:.utf8)!
+		var digestData = Data(count: Int(CC_MD5_DIGEST_LENGTH))
+		_ = digestData.withUnsafeMutableBytes { digestBytes in
+			messageData.withUnsafeBytes { messageBytes in
+				CC_MD5(messageBytes.baseAddress, CC_LONG(messageData.count), digestBytes.bindMemory(to: UInt8.self).baseAddress)
+			}
+		}
+		return digestData
+	}
+
+	var SHA1: Data {
+		let data = Data(self.utf8)
+		var digest = [UInt8](repeating: 0, count:Int(CC_SHA1_DIGEST_LENGTH))
+		data.withUnsafeBytes {
+			_ = CC_SHA1($0.baseAddress, CC_LONG(data.count), &digest)
+		}
+		return data
+	}
+
+	var MD5String: String {
+		return self.MD5.map { String(format: "%02hhx", $0) }.joined()
+	}
+
+	var SHA1String: String {
+		return self.SHA1.map { String(format: "%02hhx", $0) }.joined()
+	}
+
+}

data/Scripts/Sources/Resources/Api+Figma.swift

@@ -0,0 +1,43 @@
+import Common
+
+extension Api {
+
+	func pages(
+		token: String,
+		projectId: String,
+		page: String
+	) throws -> Figma.Pages {
+		try self.get(
+			path: "files/\(projectId)/nodes",
+			query: [
+				"ids" : page,
+				"depth": "1",
+			],
+			headers: [
+				"X-FIGMA-TOKEN" : token
+			],
+			timeoutInterval: 300
+		)
+	}
+
+	func images(
+		token: String,
+		projectId: String,
+		ids: [String],
+		scale: Int
+	) throws -> Images {
+		try self.get(
+			path: "images/\(projectId)",
+			query: [
+				"ids" : ids.joined(separator: ","),
+				"format": "jpg",
+				"scale": "\(scale)",
+			],
+			headers: [
+				"X-FIGMA-TOKEN" : token
+			],
+			timeoutInterval: 300
+		)
+	}
+
+}

data/Scripts/Sources/Resources/Deploy.swift

@@ -0,0 +1,133 @@
+import Foundation
+
+struct Deploy {
+	private let keyValue: [Deploy.NamedKey: String]
+}
+
+extension Deploy.NamedKey {
+
+	var fileName: String? {
+		switch self {
+			case .title: return "name.txt"
+			case .subtitle: return "subtitle.txt"
+			case .keywords: return "keywords.txt"
+			case .whatsNew: return "release_notes.txt"
+			default: return nil
+		}
+	}
+
+}
+
+public extension Array {
+
+	func isIndexValid(index: Int) -> Bool {
+		return index >= 0 && index < self.count
+	}
+
+	func safeObject(at index: Int) -> Element? {
+		guard self.isIndexValid(index: index) else { return nil }
+		return self[index]
+	}
+}
+
+extension String {
+	func fixedValue() -> String {
+		self
+			.replacingOccurrences(of: "\\n", with: "\n")
+			.replacingOccurrences(of: "\r", with: "")
+	}
+}
+
+extension Deploy {
+
+	enum NamedKey: String, CaseIterable {
+		case title = "Title"
+		case subtitle = "Subtitle"
+		case keywords = "keywords"
+		case iPhone8 = "iPhone8"
+		case iPhone11 = "iPhone11"
+		case whatsNew = "What's new"
+		case locale = "locale"
+		case previewTimestamp
+		case iPadPro = "iPadPro"
+		case iPadPro3Gen = "iPadPro3Gen"
+	}
+
+	init(string: String, map: [Int: NamedKey]) {
+		let cmp = string.components(separatedBy: "\t")
+		var keyValue = [Deploy.NamedKey: String]()
+		cmp.enumerated().forEach { (idx, item) in
+			if let key = map[idx] {
+				keyValue[key] = item.fixedValue()
+			}
+		}
+		self.keyValue = keyValue
+	}
+
+	subscript(key: NamedKey) -> String {
+		let text = self.keyValue[key] ?? ""
+		return text
+	}
+
+	func createFiles(at url: URL) {
+		NamedKey.allCases.forEach {
+			if let fileName = $0.fileName {
+				url.write(self[$0], to: fileName)
+			}
+		}
+	}
+
+}
+
+
+extension URL {
+
+	func write(_ text: String, to path: String) {
+		let url = self.appendingPathComponent(path)
+		do {
+			print("Write \(url.path)")
+			try text.write(to: url, atomically: true, encoding: .utf8)
+			print("Done")
+		} catch {
+			print(">>>>>\(text) write error: \(error) to path \(url)")
+		}
+
+	}
+
+}
+
+extension Deploy {
+
+	static func fromTSV(_ url: String) throws -> [Deploy] {
+		let data = try Data(contentsOf: URL(string: url)!)
+		var map = [Int: Deploy.NamedKey]()
+		let deploys: [Deploy]
+		do {
+			let tsv = String(data: data, encoding: .utf8)!.components(separatedBy: "\n")
+			guard tsv.count > 1 else { print("TSV should have more than 1 line"); exit(-1) }
+			let keys = tsv[0].components(separatedBy: "\t")
+			print("Raw keys: \(keys)")
+			keys.enumerated().forEach { (idx, key) in
+				map[idx] = Deploy.NamedKey(rawValue: key.fixedValue())
+			}
+			print("Found keys: \(map.map({ "\($0.key):\($0.value.rawValue)" }))")
+			deploys = tsv.dropFirst().map { Deploy(string: $0, map: map) }
+		}
+		return deploys
+	}
+
+}
+
+//fileprivate extension String {
+//
+//	func ids(scale: Int) -> [Deploy.IdWithScale] {
+//		return self.components(separatedBy: ",").map {
+//			($0 as NSString).trimmingCharacters(in: CharacterSet(charactersIn: "0123456789:").inverted)
+//		}.filter {
+//			!$0.isEmpty
+//		}.map {
+//			Deploy.IdWithScale(id: $0, scale: scale)
+//		}
+//	}
+//
+//}

data/Scripts/Sources/Resources/Device.swift

@@ -0,0 +1,42 @@
+enum Device: String {
+	case iPhone8
+	case iPhone11
+	case iPhone8Messages = "iPhone8-message"
+	case iPhone11Messages = "iPhone11-message"
+	case iPadPro
+	case iPadPro3Gen
+	case iPadProMessages = "iPadPro-message"
+	case iPadPro3GenMessages = "iPadPro3Gen-message"
+	case watch = "Watch"
+	case watch4 = "Watch Series4"
+}
+
+extension Device {
+	var scale: Int {
+		switch self {
+			case .iPhone8, .iPhone11, .iPhone8Messages, .iPhone11Messages: return 3
+			case .iPadPro, .iPadPro3Gen, .iPadProMessages, .iPadPro3GenMessages, .watch, .watch4: return 2
+		}
+	}
+	var isIMessage: Bool {
+		switch self {
+			case .iPadProMessages, .iPadPro3GenMessages, .iPhone8Messages, .iPhone11Messages: return true
+			default: return false
+		}
+	}
+	/// ipadPro129 это обязательный компонент имени для iPad 3 Gen, все остальное определяется по размерам
+	var id: String {
+		switch self {
+			case .iPhone8: return "APP_IPHONE_55"
+			case .iPhone11: return "APP_IPHONE_65"
+			case .iPadPro: return "ipad-pro"
+			case .iPadPro3Gen: return "ipadPro129"
+			case .iPadProMessages: return "ipad-pro"
+			case .iPadPro3GenMessages: return "ipadPro129"
+			case .iPhone8Messages: return "APP_IPHONE_55"
+			case .iPhone11Messages: return "APP_IPHONE_65"
+			case .watch: return "APP_WATCH"
+			case .watch4: return "APP_WATCH_SERIES_4"
+		}
+	}
+}

data/Scripts/Sources/Resources/DownloadBatch.swift

@@ -0,0 +1,108 @@
+import Foundation
+
+class DownloadBatch {
+
+	static let kMaximumDownloadsCount = 3
+
+	private let images: [String: String]
+	private var imagesLeft = [String: String]()
+	private let downloadGroup = DispatchGroup()
+	private let session = URLSession.shared
+	private var imageData = [String: Data]()
+	private var currentDownloadKeys = Set<String>()
+	private let url: URL
+	private let syncQueue = DispatchQueue(label: "download_image_q")
+	private var isFinished = false
+
+	init(images: [String: String], url: URL) {
+		self.images = images
+		self.imagesLeft = images
+		self.url = url
+	}
+
+	func download() -> [Figma.PageId: Data] {
+		self.downloadGroup.enter()
+		self.downloadNext()
+		self.downloadGroup.wait()
+		return self.imageData
+	}
+
+	private func downloadNext() {
+		let isFinished = self.syncQueue.sync {
+			self.imagesLeft.isEmpty && self.currentDownloadKeys.isEmpty && !self.isFinished
+		}
+		let canDonwloadMore = self.syncQueue.sync {
+			self.currentDownloadKeys.count < DownloadBatch.kMaximumDownloadsCount
+		}
+		if isFinished {
+			self.isFinished = true
+			print("Download batch finished: \(self.images)")
+			self.downloadGroup.leave()
+		} else if canDonwloadMore {
+
+			if let first = self.imagesLeft.first {
+
+				self.syncQueue.sync {
+					self.imagesLeft.removeValue(forKey: first.key)
+					self.currentDownloadKeys.insert(first.key)
+				}
+				self.downloadItem(key: first.key, value: first.value, retryCount: 5) { data in
+					self.syncQueue.sync {
+						self.imageData[first.key] = data
+						_ = self.currentDownloadKeys.remove(first.key)
+					}
+					self.downloadNext()
+				}
+				self.downloadNext()
+			}
+		}
+	}
+
+	private func downloadItem(key: String, value: String, retryCount: Int, completion: @escaping (Data?) -> Void) {
+		let data = self.syncQueue.sync {
+			self.imageData[key]
+		}
+		if data != nil {
+			completion(data); return
+		}
+		if retryCount < 0 {
+			print("⛔️ Download image \(value) retry count limit")
+			completion(nil); return
+		}
+
+		let fileUrl = self.url.appendingPathComponent(value.cacheName)
+
+		if let data = try? Data(contentsOf: fileUrl) {
+			print("✅ Image already exist at \(value.cacheName), skip download \(value)")
+			completion(data)
+			return
+		}
+
+		let imageURL = URL(string: value)!
+		print("⬇️ Download image(\(retryCount)) with url: \(value)")
+		let request = URLRequest(
+			url: imageURL,
+			cachePolicy: .reloadIgnoringLocalCacheData,
+			timeoutInterval: 7 * 60
+		)
+		self.session.downloadTask(with: request) { (url, r, e) in
+			if let url = url {
+				do {
+					let data = try Data(contentsOf: url)
+					try data.write(to: fileUrl)
+					print("✅ Did finish \(value) at \(value.cacheName)")
+					completion(data)
+				} catch {
+					print("⛔️ Did fail download, retry: \(value), \(error)")
+					self.downloadItem(key: key, value: value, retryCount: retryCount - 1, completion: completion)
+				}
+			} else {
+				if let error = e {
+					print("⛔️ Did fail download, retry: \(value), \(error)")
+				}
+				self.downloadItem(key: key, value: value, retryCount: retryCount - 1, completion: completion)
+			}
+		}.resume()
+	}
+
+}

data/Scripts/Sources/Resources/FigmaPages.swift

@@ -0,0 +1,58 @@
+enum Figma {
+	typealias Language = String
+	typealias PageId = String
+
+	struct Child: Codable {
+		let id: PageId
+		let name: String
+	}
+	struct Pages: Codable {
+		struct Node: Codable {
+			struct Document: Codable {
+				let name: String
+				let children: [Child]
+			}
+			let document: Document
+		}
+		let name: String
+		let nodes: [PageId: Node]
+	}
+	struct Screen {
+		let id: PageId
+		let locale: Language
+		let page: Int
+		let device: Device
+	}
+}
+
+extension Figma.Child {
+	func screen() -> Figma.Screen? {
+		let cmp = self.name.components(separatedBy: "/")
+		guard cmp.count == 4,
+			  cmp[0] == "screen",
+			  let device = Device(rawValue: cmp[2]),
+			  let page = Int(cmp[3]) else { return nil }
+
+		return Figma.Screen(id: self.id, locale: cmp[1], page: page, device: device)
+	}
+}
+
+extension Figma.Screen {
+	var fileName: String {
+		"\(self.device.id)_\(self.page).jpg"
+	}
+}
+
+extension Figma.Pages {
+
+	func screens(for page: String) -> [Figma.Screen] {
+		var screens = [Figma.Screen]()
+		if let node = self.nodes[page] {
+			screens = node.document.children.compactMap {
+				$0.screen()
+			}
+		}
+		return screens
+	}
+
+}