expo-tiddlywiki-filesystem-android-external-storage 2.2.10 → 2.2.13

package/ios/TarExtractor.swift

@@ -0,0 +1,158 @@
+import Foundation
+
+/// Minimal tar archive extractor — iOS equivalent of the Kotlin implementation.
+/// Supports POSIX ustar, GNU long-name (type 'L'), and POSIX pax (type 'x'/'g') extensions.
+enum TarExtractor {
+
+  private static let blockSize = 512
+
+  /// Extract an uncompressed tar archive to a destination directory.
+  /// Returns the number of files extracted.
+  static func extract(tarPath: String, destDir: String) throws -> Int {
+    let fm = FileManager.default
+    try fm.createDirectory(atPath: destDir, withIntermediateDirectories: true, attributes: nil)
+
+    guard let handle = FileHandle(forReadingAtPath: tarPath) else {
+      throw NSError(domain: "ENOENT", code: 2, userInfo: [NSLocalizedDescriptionKey: "Tar file not found: \(tarPath)"])
+    }
+    defer { handle.closeFile() }
+
+    let destURL = URL(fileURLWithPath: destDir).standardized
+    var filesExtracted = 0
+    var longName: String?
+
+    while true {
+      let headerData = handle.readData(ofLength: blockSize)
+      if headerData.count < blockSize { break }
+
+      // Check for end-of-archive (two consecutive zero blocks)
+      if headerData.allSatisfy({ $0 == 0 }) { break }
+
+      // Extract filename from header
+      let rawName = extractString(from: headerData, offset: 0, maxLen: 100)
+      let typeFlag = headerData.count > 156 ? headerData[156] : 0
+
+      // Parse file size from octal
+      let sizeString = extractString(from: headerData, offset: 124, maxLen: 12)
+      let fileSize = UInt64(sizeString.trimmingCharacters(in: .whitespaces), radix: 8) ?? 0
+
+      // POSIX ustar prefix
+      let prefix = extractString(from: headerData, offset: 345, maxLen: 155)
+
+      // Handle special entry types
+      if typeFlag == UInt8(ascii: "L") {
+        // GNU long name
+        let nameData = readExactly(handle: handle, count: Int(fileSize))
+        longName = String(data: nameData, encoding: .utf8)?.trimmingCharacters(in: CharacterSet(charactersIn: "\0"))
+        skipToBlockBoundary(handle: handle, fileSize: fileSize)
+        continue
+      }
+
+      if typeFlag == UInt8(ascii: "x") || typeFlag == UInt8(ascii: "g") {
+        // POSIX pax extended header — parse for "path" keyword
+        let paxData = readExactly(handle: handle, count: Int(fileSize))
+        skipToBlockBoundary(handle: handle, fileSize: fileSize)
+        if let paxStr = String(data: paxData, encoding: .utf8) {
+          for line in paxStr.components(separatedBy: "\n") {
+            // Format: "len key=value\n"
+            if let eqIndex = line.firstIndex(of: "=") {
+              let beforeEq = line[line.startIndex..<eqIndex]
+              if let spaceIndex = beforeEq.lastIndex(of: " ") {
+                let key = String(beforeEq[beforeEq.index(after: spaceIndex)...])
+                if key == "path" {
+                  longName = String(line[line.index(after: eqIndex)...])
+                }
+              }
+            }
+          }
+        }
+        continue
+      }
+
+      // Skip directories and non-regular files
+      if typeFlag == UInt8(ascii: "5") || typeFlag == UInt8(ascii: "2") {
+        skipDataBlocks(handle: handle, fileSize: fileSize)
+        longName = nil
+        continue
+      }
+
+      // Determine final filename
+      let entryName: String
+      if let ln = longName {
+        entryName = ln
+        longName = nil
+      } else if !prefix.isEmpty {
+        entryName = "\(prefix)/\(rawName)"
+      } else {
+        entryName = rawName
+      }
+
+      guard !entryName.isEmpty else {
+        skipDataBlocks(handle: handle, fileSize: fileSize)
+        continue
+      }
+
+      // Path traversal protection
+      let destFile = destURL.appendingPathComponent(entryName).standardized
+      guard destFile.path.hasPrefix(destURL.path) else {
+        skipDataBlocks(handle: handle, fileSize: fileSize)
+        continue
+      }
+
+      // Create parent directories
+      try fm.createDirectory(
+        at: destFile.deletingLastPathComponent(),
+        withIntermediateDirectories: true,
+        attributes: nil
+      )
+
+      // Read file content
+      let contentData = readExactly(handle: handle, count: Int(fileSize))
+      skipToBlockBoundary(handle: handle, fileSize: fileSize)
+      try contentData.write(to: destFile)
+      filesExtracted += 1
+    }
+
+    return filesExtracted
+  }
+
+  // ─── Helpers ─────────────────────────────────────────────────────
+
+  private static func extractString(from data: Data, offset: Int, maxLen: Int) -> String {
+    let end = min(offset + maxLen, data.count)
+    guard offset < end else { return "" }
+    let slice = data[offset..<end]
+    // Find null terminator
+    let nullIndex = slice.firstIndex(of: 0) ?? end
+    let stringSlice = data[offset..<nullIndex]
+    return String(data: stringSlice, encoding: .utf8) ?? ""
+  }
+
+  private static func readExactly(handle: FileHandle, count: Int) -> Data {
+    guard count > 0 else { return Data() }
+    var result = Data()
+    var remaining = count
+    while remaining > 0 {
+      let chunk = handle.readData(ofLength: remaining)
+      if chunk.isEmpty { break }
+      result.append(chunk)
+      remaining -= chunk.count
+    }
+    return result
+  }
+
+  private static func skipDataBlocks(handle: FileHandle, fileSize: UInt64) {
+    guard fileSize > 0 else { return }
+    let totalBytes = ((fileSize + UInt64(blockSize - 1)) / UInt64(blockSize)) * UInt64(blockSize)
+    handle.seek(toFileOffset: handle.offsetInFile + totalBytes)
+  }
+
+  private static func skipToBlockBoundary(handle: FileHandle, fileSize: UInt64) {
+    guard fileSize > 0 else { return }
+    let remainder = fileSize % UInt64(blockSize)
+    if remainder > 0 {
+      let padding = UInt64(blockSize) - remainder
+      handle.seek(toFileOffset: handle.offsetInFile + padding)
+    }
+  }
+}

package/ios/TiddlerParser.swift

@@ -0,0 +1,254 @@
+import Foundation
+
+/// TiddlyWiki batch file parser — iOS equivalent of the Kotlin implementation.
+/// Parses .tid, .json, and .meta files and returns a JSON array string.
+enum TiddlerParser {
+
+  /// Parse a batch of tiddler files and return a JSON array string.
+  static func batchParse(filePaths: [String], quickLoadMode: Bool) -> String {
+    let fm = FileManager.default
+    var results = [[String: Any]]()
+
+    for path in filePaths {
+      guard fm.fileExists(atPath: path) else { continue }
+      let filename = (path as NSString).lastPathComponent
+      let ext = (filename as NSString).pathExtension.lowercased()
+
+      switch ext {
+      case "tid":
+        if let tiddler = parseDotTid(path: path, quickLoadMode: quickLoadMode) {
+          results.append(tiddler)
+        }
+      case "json":
+        if let parsed = parseDotJson(path: path) {
+          if let array = parsed as? [[String: Any]] {
+            results.append(contentsOf: array)
+          } else if let single = parsed as? [String: Any] {
+            results.append(single)
+          }
+        }
+      case "meta":
+        if let tiddler = parseDotMeta(path: path, quickLoadMode: quickLoadMode) {
+          results.append(tiddler)
+        }
+      default:
+        break
+      }
+    }
+
+    guard let jsonData = try? JSONSerialization.data(withJSONObject: results, options: []) else {
+      return "[]"
+    }
+    return String(data: jsonData, encoding: .utf8) ?? "[]"
+  }
+
+  // ─── .tid parser ─────────────────────────────────────────────────
+
+  private static func parseDotTid(path: String, quickLoadMode: Bool) -> [String: Any]? {
+    guard let content = try? String(contentsOfFile: path, encoding: .utf8) else { return nil }
+
+    var fields = [String: Any]()
+
+    // Find the first blank line separating headers from body
+    let blankLinePattern = try? NSRegularExpression(pattern: "\\r?\\n\\r?\\n")
+    let range = NSRange(content.startIndex..<content.endIndex, in: content)
+    let match = blankLinePattern?.firstMatch(in: content, range: range)
+
+    let headerText: String
+    let bodyOffset: Int
+    let estimatedBodyLength: Int
+
+    if let match = match {
+      let headerRange = content.startIndex..<content.index(content.startIndex, offsetBy: match.range.location)
+      headerText = String(content[headerRange])
+      bodyOffset = match.range.location + match.range.length
+      estimatedBodyLength = content.utf8.count - bodyOffset
+    } else {
+      headerText = content
+      bodyOffset = -1
+      estimatedBodyLength = 0
+    }
+
+    // Parse header lines
+    for line in headerText.components(separatedBy: .newlines) {
+      guard let colonIndex = line.firstIndex(of: ":") else { continue }
+      let fieldName = String(line[line.startIndex..<colonIndex]).trimmingCharacters(in: .whitespaces)
+      let fieldValue = String(line[line.index(after: colonIndex)...]).trimmingCharacters(in: .whitespaces)
+      if !fieldName.isEmpty {
+        fields[fieldName] = fieldValue
+      }
+    }
+
+    // Use filename as title fallback
+    if fields["title"] == nil {
+      fields["title"] = getTitleFromFilename((path as NSString).lastPathComponent)
+    }
+
+    let title = fields["title"] as? String ?? ""
+    let type = fields["type"] as? String ?? ""
+    let hasModuleType = fields["module-type"] != nil
+    let hasPluginType = fields["plugin-type"] != nil
+
+    // Determine if we should include full text
+    let shouldIncludeText: Bool
+    if quickLoadMode {
+      shouldIncludeText = shouldPreserveFullTextInQuickLoad(
+        title: title, type: type, hasModuleType: hasModuleType, hasPluginType: hasPluginType
+      )
+    } else {
+      shouldIncludeText = shouldSaveFullTiddler(
+        title: title, type: type, hasModuleType: hasModuleType, hasPluginType: hasPluginType,
+        estimatedTextLength: estimatedBodyLength
+      )
+    }
+
+    if shouldIncludeText, bodyOffset >= 0, estimatedBodyLength > 0 {
+      let bodyStartIndex = content.index(content.startIndex, offsetBy: bodyOffset)
+      fields["text"] = String(content[bodyStartIndex...])
+    } else if !shouldIncludeText {
+      fields.removeValue(forKey: "text")
+      fields["_is_skinny"] = "yes"
+    }
+
+    return fields
+  }
+
+  // ─── .json parser ────────────────────────────────────────────────
+
+  private static func parseDotJson(path: String) -> Any? {
+    guard let data = try? Data(contentsOf: URL(fileURLWithPath: path)) else { return nil }
+
+    guard let json = try? JSONSerialization.jsonObject(with: data) else { return nil }
+
+    if let array = json as? [[String: Any]] {
+      let filtered = array.filter { $0["title"] != nil }
+      return filtered.isEmpty ? nil : filtered
+    } else if let obj = json as? [String: Any] {
+      if obj["title"] != nil {
+        return obj
+      }
+      // Plugin bundle format — skip
+      return nil
+    }
+    return nil
+  }
+
+  // ─── .meta parser ───────────────────────────────────────────────
+
+  private static let textCompanionExtensions: Set<String> = [
+    "json", "js", "css", "svg", "txt", "html", "htm"
+  ]
+
+  private static func parseDotMeta(path: String, quickLoadMode: Bool) -> [String: Any]? {
+    guard let metaContent = try? String(contentsOfFile: path, encoding: .utf8) else { return nil }
+
+    var fields = [String: Any]()
+
+    for line in metaContent.components(separatedBy: .newlines) {
+      guard let colonIndex = line.firstIndex(of: ":") else { continue }
+      let fieldName = String(line[line.startIndex..<colonIndex]).trimmingCharacters(in: .whitespaces)
+      let fieldValue = String(line[line.index(after: colonIndex)...]).trimmingCharacters(in: .whitespaces)
+      if !fieldName.isEmpty {
+        fields[fieldName] = fieldValue
+      }
+    }
+
+    if fields["title"] == nil {
+      let metaFilename = (path as NSString).lastPathComponent
+      let baseName = (metaFilename as NSString).deletingPathExtension  // removes .meta
+      fields["title"] = getTitleFromFilename(baseName)
+    }
+
+    // Find companion file
+    let companionPath = (path as NSString).deletingPathExtension  // removes .meta
+    let fm = FileManager.default
+
+    if fm.fileExists(atPath: companionPath) {
+      let companionExt = (companionPath as NSString).pathExtension.lowercased()
+
+      if companionExt == "json" {
+        // .meta + .json pair
+        let title = fields["title"] as? String ?? ""
+        let type = fields["type"] as? String ?? ""
+        let hasModuleType = fields["module-type"] != nil
+        let hasPluginType = fields["plugin-type"] != nil
+
+        let shouldIncludeText: Bool
+        if quickLoadMode {
+          shouldIncludeText = shouldPreserveFullTextInQuickLoad(
+            title: title, type: type, hasModuleType: hasModuleType, hasPluginType: hasPluginType
+          )
+        } else {
+          shouldIncludeText = true
+        }
+
+        if shouldIncludeText {
+          if let jsonContent = try? String(contentsOfFile: companionPath, encoding: .utf8) {
+            fields["text"] = jsonContent
+          }
+        } else {
+          fields["_is_skinny"] = "yes"
+        }
+      } else if textCompanionExtensions.contains(companionExt) {
+        // Text companion — include if not quick-load-skinny
+        let title = fields["title"] as? String ?? ""
+        let type = fields["type"] as? String ?? ""
+        let hasModuleType = fields["module-type"] != nil
+        let hasPluginType = fields["plugin-type"] != nil
+
+        let shouldIncludeText: Bool
+        if quickLoadMode {
+          shouldIncludeText = shouldPreserveFullTextInQuickLoad(
+            title: title, type: type, hasModuleType: hasModuleType, hasPluginType: hasPluginType
+          )
+        } else {
+          shouldIncludeText = true
+        }
+
+        if shouldIncludeText {
+          if let textContent = try? String(contentsOfFile: companionPath, encoding: .utf8) {
+            fields["text"] = textContent
+          }
+        } else {
+          fields["_is_skinny"] = "yes"
+        }
+      }
+      // Binary companions (images etc.) — no text set
+    }
+
+    return fields["title"] != nil ? fields : nil
+  }
+
+  // ─── Helpers ─────────────────────────────────────────────────────
+
+  static func getTitleFromFilename(_ filename: String) -> String {
+    var name = filename
+    for ext in [".tid", ".json", ".meta"] {
+      if name.lowercased().hasSuffix(ext) {
+        name = String(name.dropLast(ext.count))
+        break
+      }
+    }
+    return name
+  }
+
+  static func shouldSaveFullTiddler(
+    title: String, type: String, hasModuleType: Bool, hasPluginType: Bool,
+    estimatedTextLength: Int
+  ) -> Bool {
+    if shouldPreserveFullTextInQuickLoad(title: title, type: type, hasModuleType: hasModuleType, hasPluginType: hasPluginType) {
+      return true
+    }
+    if estimatedTextLength < 10000 { return true }
+    return false
+  }
+
+  static func shouldPreserveFullTextInQuickLoad(
+    title: String, type: String, hasModuleType: Bool, hasPluginType: Bool
+  ) -> Bool {
+    if title.hasPrefix("$:/") { return true }
+    if type == "application/json" && hasPluginType { return true }
+    if hasModuleType { return true }
+    return false
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "expo-tiddlywiki-filesystem-android-external-storage",
-  "version": "2.2.10",
-  "description": "Expo native module for TidGi-Mobile: external storage I/O + TiddlyWiki .tid/.meta/.json batch parsing in Kotlin",
+  "version": "2.2.13",
+  "description": "Expo native module for TidGi-Mobile: filesystem I/O + TiddlyWiki .tid/.meta/.json batch parsing + git status in Kotlin (Android) and Swift (iOS)",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "plugin": "app.plugin.js",
@@ -39,6 +39,7 @@
   "files": [
     "build",
     "android",
+    "ios",
     "expo-module.config.json",
     "src",
     "plugin.js",

package/src/index.ts

@@ -19,8 +19,8 @@ let _module: IExternalStorageModule | undefined;
  */
 function getNativeModule(): IExternalStorageModule {
   if (_module) return _module;
-  if (Platform.OS !== 'android') {
-    throw new Error('ExternalStorage native module is only available on Android');
+  if (Platform.OS !== 'android' && Platform.OS !== 'ios') {
+    throw new Error('ExternalStorage native module is only available on Android and iOS');
   }
   // eslint-disable-next-line @typescript-eslint/no-require-imports
   const { requireNativeModule } = require('expo-modules-core') as { requireNativeModule: (name: string) => IExternalStorageModule };