@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/_FoundationCommon/Bundle.swift

@@ -0,0 +1,82 @@
+// `Bundle` for the browser: the app's resource files (what the Xcode target's
+// Copy Bundle Resources phase lists, or `resources` in swiftbrowser.json) are
+// served next to the module and mounted by the host at `/bundle` in the WASI
+// filesystem before `main` runs, so `Data(contentsOf:)` and friends read them
+// like any file. corelibs Foundation's `Bundle.main` traps on WASI; this one
+// answers the resource lookups apps make. Headless runs mount a directory
+// through `SB_BUNDLE_DIR` (scripts/run-wasi.mjs).
+
+import FoundationEssentials
+import SwiftUI
+
+public final class Bundle: @unchecked Sendable {
+    /// Where the host mounts the resources (`SB_BUNDLE_PATH`, default `/bundle`).
+    nonisolated(unsafe) public static let main = Bundle(path: _environment("SB_BUNDLE_PATH") ?? "/bundle")!
+
+    public let bundlePath: String
+
+    public init?(path: String) {
+        bundlePath = path.hasSuffix("/") && path.count > 1 ? String(path.dropLast()) : path
+    }
+    public convenience init?(url: URL) { self.init(path: url.path) }
+    /// Every class lives in the one bundle.
+    public convenience init(for aClass: AnyClass) { self.init(path: Bundle.main.bundlePath)! }
+    public convenience init?(identifier: String) { self.init(path: Bundle.main.bundlePath) }
+
+    public var bundleURL: URL { URL(fileURLWithPath: bundlePath, isDirectory: true) }
+    public var resourcePath: String? { bundlePath }
+    public var resourceURL: URL? { bundleURL }
+    public var executablePath: String? { nil }
+    public var bundleIdentifier: String? { _environment("SB_BUNDLE_ID") }
+    public var infoDictionary: [String: Any]? {
+        var info: [String: Any] = [:]
+        if let id = bundleIdentifier { info["CFBundleIdentifier"] = id }
+        if let name = _environment("SB_APP_NAME") { info["CFBundleName"] = name; info["CFBundleDisplayName"] = name }
+        return info
+    }
+    public func object(forInfoDictionaryKey key: String) -> Any? { infoDictionary?[key] }
+
+    // MARK: Resources
+
+    public func path(forResource name: String?, ofType ext: String?) -> String? {
+        path(forResource: name, ofType: ext, inDirectory: nil)
+    }
+
+    public func path(forResource name: String?, ofType ext: String?, inDirectory subpath: String?) -> String? {
+        guard let name, !name.isEmpty else { return nil }
+        var file = name
+        if let ext, !ext.isEmpty, !name.hasSuffix(".\(ext)") { file += ".\(ext)" }
+        var components = [bundlePath]
+        if let subpath, !subpath.isEmpty { components.append(subpath) }
+        components.append(file)
+        let path = components.joined(separator: "/")
+        return FileManager.default.fileExists(atPath: path) ? path : nil
+    }
+
+    public func url(forResource name: String?, withExtension ext: String?) -> URL? {
+        path(forResource: name, ofType: ext).map { URL(fileURLWithPath: $0) }
+    }
+
+    public func url(forResource name: String?, withExtension ext: String?, subdirectory subpath: String?) -> URL? {
+        path(forResource: name, ofType: ext, inDirectory: subpath).map { URL(fileURLWithPath: $0) }
+    }
+
+    /// Every resource with the extension (`nil`: all files) in the bundle or a subdirectory.
+    public func urls(forResourcesWithExtension ext: String?, subdirectory subpath: String?) -> [URL]? {
+        let dir = subpath.map { "\(bundlePath)/\($0)" } ?? bundlePath
+        guard let names = try? FileManager.default.contentsOfDirectory(atPath: dir) else { return nil }
+        return names.sorted()
+            .filter { ext == nil || ext!.isEmpty || $0.hasSuffix(".\(ext!)") }
+            .map { URL(fileURLWithPath: "\(dir)/\($0)") }
+    }
+
+    public func paths(forResourcesOfType ext: String?, inDirectory subpath: String?) -> [String] {
+        urls(forResourcesWithExtension: ext, subdirectory: subpath)?.map(\.path) ?? []
+    }
+
+    /// No string tables are loaded: the key (or `value` when given) comes back.
+    public func localizedString(forKey key: String, value: String?, table: String?) -> String {
+        if let value, !value.isEmpty { return value }
+        return key
+    }
+}

package/Sources/_FoundationCommon/UserDefaults.swift

@@ -0,0 +1,170 @@
+// `UserDefaults` that survives reloads. Values live in memory and are mirrored
+// to the host: every change is sent as a `defaults` op (the whole dictionary
+// as JSON), which the browser stores per app in localStorage and hands back at
+// the next launch through the `SB_DEFAULTS` environment variable. Headless
+// runs print the op like any other, so a snapshot shows what an app saves.
+//
+// JSON cannot tell an Int from a Double or carry Data and Date; integers
+// travel as whole numbers (and come back as Int), `Data` as `{"$data": base64}`,
+// `Date` as `{"$date": seconds}`, `URL` as `{"$url": string}`.
+
+import FoundationEssentials
+import SwiftUI
+
+public final class UserDefaults: @unchecked Sendable {
+    nonisolated(unsafe) public static let standard = UserDefaults(persistent: true)
+
+    private var storage: [String: Any] = [:]
+    private var registered: [String: Any] = [:]
+    private let persistent: Bool
+
+    init(persistent: Bool) {
+        self.persistent = persistent
+        if persistent, let text = _environment("SB_DEFAULTS"), let json = try? _JSON.parse(text), case .object(let values) = json {
+            for (key, value) in values { storage[key] = _defaultsValue(fromJSON: value) }
+        }
+    }
+
+    public convenience init() { self.init(persistent: false) }
+    /// Suites are not separated: every suite is the standard defaults.
+    public convenience init?(suiteName: String?) { self.init(persistent: true) }
+
+    // MARK: Reading
+
+    public func object(forKey key: String) -> Any? { storage[key] ?? registered[key] }
+    public func string(forKey key: String) -> String? {
+        switch object(forKey: key) {
+        case let s as String: s
+        case let n as Int: String(n)
+        case let n as Double: String(n)
+        default: nil
+        }
+    }
+    public func array(forKey key: String) -> [Any]? { object(forKey: key) as? [Any] }
+    public func dictionary(forKey key: String) -> [String: Any]? { object(forKey: key) as? [String: Any] }
+    public func data(forKey key: String) -> Data? { object(forKey: key) as? Data }
+    public func stringArray(forKey key: String) -> [String]? {
+        guard let array = object(forKey: key) as? [Any] else { return nil }
+        let strings = array.compactMap { $0 as? String }
+        return strings.count == array.count ? strings : nil
+    }
+    public func url(forKey key: String) -> URL? {
+        switch object(forKey: key) {
+        case let url as URL: url
+        case let s as String: URL(string: s)
+        default: nil
+        }
+    }
+    public func integer(forKey key: String) -> Int {
+        switch object(forKey: key) {
+        case let n as Int: n
+        case let n as Double: Int(n)
+        case let s as String: Int(s) ?? 0
+        case let b as Bool: b ? 1 : 0
+        default: 0
+        }
+    }
+    public func float(forKey key: String) -> Float { Float(double(forKey: key)) }
+    public func double(forKey key: String) -> Double {
+        switch object(forKey: key) {
+        case let n as Double: n
+        case let n as Int: Double(n)
+        case let s as String: Double(s) ?? 0
+        case let b as Bool: b ? 1 : 0
+        default: 0
+        }
+    }
+    public func bool(forKey key: String) -> Bool {
+        switch object(forKey: key) {
+        case let b as Bool: b
+        case let n as Int: n != 0
+        case let n as Double: n != 0
+        case let s as String: s == "true" || s == "YES" || s == "1"
+        default: false
+        }
+    }
+
+    // MARK: Writing
+
+    public func set(_ value: Any?, forKey key: String) {
+        if let value { storage[key] = value } else { storage[key] = nil }
+        persist()
+    }
+    public func set(_ value: Int, forKey key: String) { set(value as Any, forKey: key) }
+    public func set(_ value: Double, forKey key: String) { set(value as Any, forKey: key) }
+    public func set(_ value: Float, forKey key: String) { set(Double(value) as Any, forKey: key) }
+    public func set(_ value: Bool, forKey key: String) { set(value as Any, forKey: key) }
+    public func set(_ url: URL?, forKey key: String) { set(url as Any?, forKey: key) }
+    public func removeObject(forKey key: String) { set(nil, forKey: key) }
+
+    /// Fallback values, read when nothing was set; never persisted.
+    public func register(defaults: [String: Any]) {
+        for (key, value) in defaults { registered[key] = value }
+    }
+    public func dictionaryRepresentation() -> [String: Any] {
+        var all = registered
+        for (key, value) in storage { all[key] = value }
+        return all
+    }
+    public func removePersistentDomain(forName domainName: String) {
+        storage.removeAll()
+        persist()
+    }
+    @discardableResult public func synchronize() -> Bool { true }
+
+    /// The saved values as the host stores them.
+    public var _json: _JSON {
+        var fields: [String: _JSON] = [:]
+        for (key, value) in storage {
+            if let json = _defaultsJSON(from: value) { fields[key] = json }
+        }
+        return .object(fields)
+    }
+
+    private func persist() {
+        guard persistent else { return }
+        let json = _json
+        MainActor.assumeIsolated { _Runtime.shared.storeDefaults(json) }
+    }
+}
+
+/// A defaults value as JSON; nil for a type the store cannot carry.
+func _defaultsJSON(from value: Any) -> _JSON? {
+    switch value {
+    case let v as String: return .string(v)
+    case let v as Bool: return .bool(v)
+    case let v as Int: return .number(Double(v))
+    case let v as Double: return .number(v)
+    case let v as Float: return .number(Double(v))
+    case let v as Data: return .object(["$data": .string(v.base64EncodedString())])
+    case let v as Date: return .object(["$date": .number(v.timeIntervalSince1970)])
+    case let v as URL: return .object(["$url": .string(v.absoluteString)])
+    case let v as [Any]: return .array(v.compactMap(_defaultsJSON(from:)))
+    case let v as [String: Any]:
+        var fields: [String: _JSON] = [:]
+        for (key, item) in v { if let json = _defaultsJSON(from: item) { fields[key] = json } }
+        return .object(fields)
+    default:
+        print("[UserDefaults] cannot save a value of type \(type(of: value)); use a property-list type")
+        return nil
+    }
+}
+
+func _defaultsValue(fromJSON json: _JSON) -> Any? {
+    switch json {
+    case .null: return nil
+    case .bool(let b): return b
+    case .string(let s): return s
+    case .number(let n): return n == n.rounded() && abs(n) < 9_007_199_254_740_992 ? Int(n) as Any : n
+    case .array(let items): return items.compactMap(_defaultsValue(fromJSON:))
+    case .object(let fields):
+        if fields.count == 1 {
+            if case .string(let b64)? = fields["$data"], let data = Data(base64Encoded: b64) { return data }
+            if case .number(let seconds)? = fields["$date"] { return Date(timeIntervalSince1970: seconds) }
+            if case .string(let text)? = fields["$url"], let url = URL(string: text) { return url }
+        }
+        var out: [String: Any] = [:]
+        for (key, item) in fields { if let value = _defaultsValue(fromJSON: item) { out[key] = value } }
+        return out
+    }
+}

package/Sources/_FoundationCommon/_FoundationCommon.swift

@@ -0,0 +1,10 @@
+/// What FoundationLite (lean builds) and FoundationBridge (full builds) share:
+/// the browser's `UserDefaults` and `Bundle`. Both are written against
+/// FoundationEssentials, whose `Data`, `Date`, `URL` and `FileManager` are the
+/// very types the full Foundation re-exports, so one implementation serves
+/// both modes. FoundationLite re-exports this module; FoundationBridge aliases
+/// the two classes, and the CLI's generated file aliases them again in the app
+/// so they shadow corelibs Foundation's (whose `UserDefaults` cannot persist
+/// and whose `Bundle.main` traps on WASI). See docs/ops-protocol.md, "Phase 11".
+import FoundationEssentials
+import SwiftUI

package/index.d.ts

@@ -0,0 +1,2 @@
+/** Absolute path of a directory holding a Package.swift with the SwiftUI, Charts and FoundationLite products. */
+export function swiftPackagePath(): string;

package/index.mjs

@@ -0,0 +1,16 @@
+// Where the Swift package lives: next to this file once `Sources/` was synced
+// (a published tarball), else the repository root (a checkout, whose
+// Package.swift carries the same library products plus the examples).
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+/** Absolute path of a directory holding a Package.swift with the SwiftUI, Charts, FoundationLite and FoundationBridge products. */
+export function swiftPackagePath() {
+  if (existsSync(path.join(here, 'Sources', 'SwiftUI'))) return here;
+  const repoRoot = path.resolve(here, '../..');
+  if (existsSync(path.join(repoRoot, 'Package.swift')) && existsSync(path.join(repoRoot, 'Sources', 'SwiftUI'))) return repoRoot;
+  throw new Error(`@swiftbrowser/swift: no Swift package found at ${here} or ${repoRoot}`);
+}

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@swiftbrowser/swift",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The SwiftBrowser Swift package (the SwiftUI shim, Charts, FoundationLite and FoundationBridge) as an npm package, so @swiftbrowser/cli builds apps against the exact version it ships with.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dabbott/SwiftBrowser.git",
+    "directory": "packages/swift"
+  },
+  "files": [
+    "Package.swift",
+    "Sources",
+    "index.mjs",
+    "index.d.ts",
+    "sync-sources.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "node sync-sources.mjs"
+  },
+  "type": "module",
+  "main": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.mjs"
+    }
+  }
+}

package/sync-sources.mjs

@@ -0,0 +1,19 @@
+// `npm pack` / `npm publish` hook: copy the repository's Sources/ (the SwiftUI
+// shim, Charts, FoundationLite, FoundationBridge) into this package so the published tarball is a
+// complete Swift package. The copy is gitignored.
+import { cpSync, existsSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoSources = path.resolve(here, '../../Sources');
+const dest = path.join(here, 'Sources');
+if (!existsSync(repoSources)) {
+  console.error(`sync-sources: ${repoSources} not found; run from a repository checkout`);
+  process.exit(1);
+}
+rmSync(dest, { recursive: true, force: true });
+for (const target of ['SwiftUI', 'Charts', '_FoundationCommon', 'FoundationLite', 'FoundationBridge']) {
+  cpSync(path.join(repoSources, target), path.join(dest, target), { recursive: true });
+}
+console.log(`sync-sources: copied Sources/{SwiftUI,Charts,_FoundationCommon,FoundationLite,FoundationBridge} into ${dest}`);