@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/CoreGraphics/CoreGraphics.swift

@@ -0,0 +1,411 @@
+// `import CoreGraphics` for the browser. The geometry types and `CGImage`
+// are the SwiftUI shim's (re-exported, as on Apple platforms SwiftUI uses
+// Core Graphics' own); this module adds what image code draws with.
+//
+// A `CGImage` holds no pixels: it is a recipe the page runs (a decoded file,
+// then steps; Runtime/ImageSource.swift). So a `CGContext` records too.
+// Drawing an image into it places that image's recipe in the context's
+// rectangle (`place`), a clip to a rounded rectangle or an ellipse masks it
+// (`roundedClip`), and `makeImage()` renders the context's rectangle: the
+// same recipe, cut to the canvas. That covers what image libraries draw
+// (decompressing, resizing, cropping, rounding corners). Only the last image
+// drawn is kept, fills and strokes are not drawn, and `data` is never
+// written: code that reads pixels back gets zeros. See docs/ops-protocol.md,
+// "Core Graphics and Image I/O".
+
+@_exported import typealias SwiftUI.CGFloat
+@_exported import struct SwiftUI.CGPoint
+@_exported import struct SwiftUI.CGSize
+@_exported import struct SwiftUI.CGRect
+@_exported import class SwiftUI.CGImage
+@_exported import enum SwiftUI.CGLineCap
+@_exported import enum SwiftUI.CGLineJoin
+@_exported import struct SwiftUI.CGAffineTransform
+import SwiftUI
+
+// MARK: - Colors
+
+/// A color space. Every bitmap here is device RGB.
+public final class CGColorSpace: @unchecked Sendable {
+    public let name: String?
+    public init?(name: String) { self.name = name }
+    init(_name name: String) { self.name = name }
+
+    public var numberOfComponents: Int { 3 }
+    public var model: CGColorSpaceModel { .rgb }
+
+    public static let sRGB = "kCGColorSpaceSRGB"
+    public static let displayP3 = "kCGColorSpaceDisplayP3"
+    public static let genericRGBLinear = "kCGColorSpaceGenericRGBLinear"
+    public static let linearSRGB = "kCGColorSpaceLinearSRGB"
+    public static let extendedSRGB = "kCGColorSpaceExtendedSRGB"
+    public static let genericGrayGamma2_2 = "kCGColorSpaceGenericGrayGamma2_2"
+}
+
+public enum CGColorSpaceModel: Int32, Sendable {
+    case unknown = -1, monochrome, rgb, cmyk, lab, deviceN, indexed, pattern, XYZ
+}
+
+public func CGColorSpaceCreateDeviceRGB() -> CGColorSpace { CGColorSpace(_name: CGColorSpace.sRGB) }
+public func CGColorSpaceCreateDeviceGray() -> CGColorSpace { CGColorSpace(_name: CGColorSpace.genericGrayGamma2_2) }
+
+/// A color: RGBA components in 0…1.
+public final class CGColor: @unchecked Sendable {
+    public let components: [CGFloat]?
+    public var alpha: CGFloat { components?.last ?? 1 }
+    public var numberOfComponents: Int { components?.count ?? 0 }
+    public var colorSpace: CGColorSpace? { CGColorSpaceCreateDeviceRGB() }
+
+    public init(red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
+        components = [red, green, blue, alpha]
+    }
+
+    public init(gray: CGFloat, alpha: CGFloat) {
+        components = [gray, gray, gray, alpha]
+    }
+
+    public init?(colorSpace: CGColorSpace, components: UnsafePointer<CGFloat>) {
+        self.components = Array(UnsafeBufferPointer(start: components, count: 4))
+    }
+
+    public func copy(alpha: CGFloat) -> CGColor? {
+        let c = components ?? [0, 0, 0, 1]
+        return CGColor(red: c[0], green: c[1], blue: c[2], alpha: alpha)
+    }
+
+    public static let black = CGColor(gray: 0, alpha: 1)
+    public static let white = CGColor(gray: 1, alpha: 1)
+    public static let clear = CGColor(gray: 0, alpha: 0)
+}
+
+// MARK: - Bitmap formats
+
+/// How a bitmap stores alpha. Recorded; the page's bitmaps are premultiplied RGBA.
+public enum CGImageAlphaInfo: UInt32, Sendable {
+    case none = 0, premultipliedLast, premultipliedFirst, last, first, noneSkipLast, noneSkipFirst, alphaOnly
+}
+
+public struct CGBitmapInfo: OptionSet, Sendable {
+    public let rawValue: UInt32
+    public init(rawValue: UInt32) { self.rawValue = rawValue }
+    public init(_ rawValue: UInt32) { self.rawValue = rawValue }
+
+    public static let alphaInfoMask = CGBitmapInfo(rawValue: 0x1F)
+    public static let floatInfoMask = CGBitmapInfo(rawValue: 0xF00)
+    public static let floatComponents = CGBitmapInfo(rawValue: 1 << 8)
+    public static let byteOrderMask = CGBitmapInfo(rawValue: 0x7000)
+    public static let byteOrderDefault = CGBitmapInfo([])
+    public static let byteOrder16Little = CGBitmapInfo(rawValue: 1 << 12)
+    public static let byteOrder32Little = CGBitmapInfo(rawValue: 2 << 12)
+    public static let byteOrder16Big = CGBitmapInfo(rawValue: 3 << 12)
+    public static let byteOrder32Big = CGBitmapInfo(rawValue: 4 << 12)
+}
+
+public enum CGInterpolationQuality: Int32, Sendable {
+    case `default` = 0, none, low, medium, high
+}
+
+public enum CGBlendMode: Int32, Sendable {
+    case normal = 0, multiply, screen, overlay, darken, lighten, colorDodge, colorBurn, softLight, hardLight
+    case difference, exclusion, hue, saturation, color, luminosity, clear, copy, sourceIn, sourceOut
+    case sourceAtop, destinationOver, destinationIn, destinationOut, destinationAtop, xor, plusDarker, plusLighter
+}
+
+public enum CGPathFillRule: Int, Sendable {
+    case winding = 0, evenOdd
+}
+
+/// Where a bitmap's bytes come from. Always empty here: the page holds the pixels.
+public final class CGDataProvider: @unchecked Sendable {
+    public init?(data: Any) { return nil }
+    public var data: Any? { nil }
+}
+
+extension CGImage {
+    public var colorSpace: CGColorSpace? { CGColorSpaceCreateDeviceRGB() }
+    public var alphaInfo: CGImageAlphaInfo { .premultipliedLast }
+    public var bitmapInfo: CGBitmapInfo { CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue) }
+    public var isMask: Bool { false }
+    public var shouldInterpolate: Bool { true }
+    public var renderingIntent: CGColorRenderingIntent { .defaultIntent }
+    /// Nil: the pixels are the page's.
+    public var dataProvider: CGDataProvider? { nil }
+}
+
+public enum CGColorRenderingIntent: Int32, Sendable {
+    case defaultIntent = 0, absoluteColorimetric, relativeColorimetric, perceptual, saturation
+}
+
+// MARK: - Integer geometry
+
+// Core Graphics' initializers from integers (the shim's types take CGFloat).
+extension CGPoint {
+    public init(x: Int, y: Int) { self.init(x: CGFloat(x), y: CGFloat(y)) }
+}
+
+extension CGSize {
+    public init(width: Int, height: Int) { self.init(width: CGFloat(width), height: CGFloat(height)) }
+}
+
+extension CGRect {
+    public init(x: Int, y: Int, width: Int, height: Int) {
+        self.init(x: CGFloat(x), y: CGFloat(y), width: CGFloat(width), height: CGFloat(height))
+    }
+}
+
+// MARK: - Paths
+
+/// A path. The shapes image code clips to are kept as such (a rectangle, a
+/// rounded rectangle, an ellipse); anything else is its bounding box.
+public class CGPath: @unchecked Sendable {
+    enum Shape: Equatable {
+        case rect(CGRect)
+        case roundedRect(CGRect, cornerWidth: CGFloat, cornerHeight: CGFloat)
+        case ellipse(CGRect)
+    }
+
+    var shapes: [Shape] = []
+
+    public init() {}
+
+    public convenience init(rect: CGRect, transform: UnsafePointer<CGAffineTransform>?) {
+        self.init()
+        shapes = [.rect(rect.applying(transform?.pointee ?? .identity))]
+    }
+
+    public convenience init(roundedRect rect: CGRect, cornerWidth: CGFloat, cornerHeight: CGFloat, transform: UnsafePointer<CGAffineTransform>?) {
+        self.init()
+        shapes = [.roundedRect(rect.applying(transform?.pointee ?? .identity), cornerWidth: cornerWidth, cornerHeight: cornerHeight)]
+    }
+
+    public convenience init(ellipseIn rect: CGRect, transform: UnsafePointer<CGAffineTransform>?) {
+        self.init()
+        shapes = [.ellipse(rect.applying(transform?.pointee ?? .identity))]
+    }
+
+    public var boundingBox: CGRect {
+        shapes.reduce(CGRect.null) { box, shape in
+            switch shape {
+            case .rect(let r), .ellipse(let r), .roundedRect(let r, _, _): box.union(r)
+            }
+        }
+    }
+
+    public var isEmpty: Bool { shapes.isEmpty }
+}
+
+public final class CGMutablePath: CGPath, @unchecked Sendable {
+    public override init() { super.init() }
+
+    public func addRect(_ rect: CGRect, transform: CGAffineTransform = .identity) { shapes.append(.rect(rect.applying(transform))) }
+    public func addEllipse(in rect: CGRect, transform: CGAffineTransform = .identity) { shapes.append(.ellipse(rect.applying(transform))) }
+    public func addRoundedRect(in rect: CGRect, cornerWidth: CGFloat, cornerHeight: CGFloat, transform: CGAffineTransform = .identity) {
+        shapes.append(.roundedRect(rect.applying(transform), cornerWidth: cornerWidth, cornerHeight: cornerHeight))
+    }
+    public func addPath(_ path: CGPath, transform: CGAffineTransform = .identity) { shapes += path.shapes }
+    public func move(to point: CGPoint, transform: CGAffineTransform = .identity) {}
+    public func addLine(to point: CGPoint, transform: CGAffineTransform = .identity) {}
+    public func closeSubpath() {}
+}
+
+// MARK: - Contexts
+
+/// A bitmap context that records what is drawn into it as recipe steps.
+public final class CGContext: @unchecked Sendable {
+    public let width: Int
+    public let height: Int
+    public let bitsPerComponent: Int
+    public let bytesPerRow: Int
+    public let colorSpace: CGColorSpace?
+    public let bitmapInfo: UInt32
+    public var alphaInfo: CGImageAlphaInfo { CGImageAlphaInfo(rawValue: bitmapInfo & 0x1F) ?? .premultipliedLast }
+    public var interpolationQuality: CGInterpolationQuality = .default
+    /// The bitmap's memory. The pixels are the page's, so this is never drawn
+    /// into: a context made without memory gets zeroed memory of its size on
+    /// first use, which also identifies the context to Accelerate's vImage
+    /// functions (they turn a convolution of it into a recipe step).
+    public var data: UnsafeMutableRawPointer? {
+        if let providedData { return providedData }
+        if let ownedData { return ownedData }
+        let size = max(1, bytesPerRow * height)
+        let memory = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: 16)
+        memory.initializeMemory(as: UInt8.self, repeating: 0, count: size)
+        ownedData = memory
+        Self.registry[memory] = _WeakContext(self)
+        return memory
+    }
+    private let providedData: UnsafeMutableRawPointer?
+    private var ownedData: UnsafeMutableRawPointer?
+
+    final class _WeakContext { weak var context: CGContext?; init(_ context: CGContext) { self.context = context } }
+    nonisolated(unsafe) static var registry: [UnsafeMutableRawPointer: _WeakContext] = [:]
+
+    /// The context whose `data` this is, if any.
+    public static func _context(withData data: UnsafeMutableRawPointer?) -> CGContext? {
+        guard let data else { return nil }
+        return registry[data]?.context
+    }
+
+    deinit {
+        for memory in [providedData, ownedData].compactMap({ $0 }) where Self.registry[memory]?.context == nil || Self.registry[memory]?.context === self {
+            Self.registry[memory] = nil
+        }
+        ownedData?.deallocate()
+    }
+
+    /// The image drawn last, already placed in the canvas (y up, as Core Graphics draws).
+    private var content: _ImageRecipe?
+    /// Whether `content` is the image drawn last exactly as it was (drawn at its own size, at the origin).
+    private var contentIsUntouched = false
+    private var contentSource: CGImage?
+    private var ctm: CGAffineTransform = .identity
+    private var path: [CGPath.Shape] = []
+    private var clipShape: CGPath.Shape?
+    private var states: [(CGAffineTransform, CGPath.Shape?)] = []
+
+    public init?(data: UnsafeMutableRawPointer?, width: Int, height: Int, bitsPerComponent: Int, bytesPerRow: Int, space: CGColorSpace, bitmapInfo: UInt32) {
+        guard width > 0, height > 0 else { return nil }
+        providedData = data
+        self.width = width
+        self.height = height
+        self.bitsPerComponent = bitsPerComponent
+        self.bytesPerRow = bytesPerRow
+        self.colorSpace = space
+        self.bitmapInfo = bitmapInfo
+        if let data { Self.registry[data] = _WeakContext(self) }
+    }
+
+    var canvas: CGRect { CGRect(x: 0, y: 0, width: Double(width), height: Double(height)) }
+
+    /// Draws `image` scaled into `rect`, through the current transform and clip.
+    public func draw(_ image: CGImage, in rect: CGRect, byTiling: Bool = false) {
+        let target = rect.applying(ctm)
+        let source = image._recipe
+        let w = Double(image.width), h = Double(image.height)
+        guard w > 0, h > 0, target.width > 0, target.height > 0 else { return }
+        var recipe = source
+        let identity = target == CGRect(x: 0, y: 0, width: w, height: h)
+        if !identity {
+            recipe = recipe.adding(.object([
+                "op": .string("place"),
+                "sx": .number(target.width / w), "sy": .number(target.height / h),
+                "tx": .number(target.minX), "ty": .number(target.minY),
+            ]), extent: target)
+        }
+        if let clipShape { recipe = Self.clipped(recipe, to: clipShape) }
+        content = recipe
+        contentIsUntouched = identity && clipShape == nil
+        contentSource = image
+    }
+
+    static func clipped(_ recipe: _ImageRecipe, to shape: CGPath.Shape) -> _ImageRecipe {
+        let (rect, rx, ry): (CGRect, CGFloat, CGFloat) = switch shape {
+        case .rect(let r): (r, 0, 0)
+        case .roundedRect(let r, let cw, let ch): (r, cw, ch)
+        case .ellipse(let r): (r, r.width / 2, r.height / 2)
+        }
+        let extent = recipe.extent.intersection(rect)
+        return recipe.adding(.object([
+            "op": .string("roundedClip"),
+            "x": .number(rect.minX), "y": .number(rect.minY), "width": .number(rect.width), "height": .number(rect.height),
+            "rx": .number(rx), "ry": .number(ry),
+        ]), extent: extent.isNull ? .zero : extent)
+    }
+
+    /// What vImage's box convolution makes of `source`'s pixels in this
+    /// context: `source`'s canvas, blurred. A box of k pixels has the variance
+    /// of a Gaussian with σ² = (k² − 1) / 12, so each pass is a `gaussianBlur`
+    /// step of that radius (passes compose as their variances add). Edge
+    /// extension is a `clamp` first.
+    public func _boxConvolve(from source: CGContext, kernelWidth: Int, kernelHeight: Int, extendEdges: Bool) {
+        guard let sourceContent = source.content else {
+            content = nil
+            contentIsUntouched = false
+            contentSource = nil
+            return
+        }
+        let k2 = (Double(kernelWidth * kernelWidth) + Double(kernelHeight * kernelHeight)) / 2
+        let sigma = ((k2 - 1) / 12).squareRoot()
+        let canvas = source.canvas
+        func crop(_ r: CGRect) -> _JSON {
+            .object(["op": .string("crop"), "x": .number(r.minX), "y": .number(r.minY), "width": .number(r.width), "height": .number(r.height)])
+        }
+        var recipe = sourceContent.adding(crop(canvas), extent: canvas.intersection(sourceContent.extent))
+        if extendEdges { recipe = recipe.adding(.object(["op": .string("clamp")]), extent: .infinite) }
+        if sigma > 0 { recipe = recipe.adding(.object(["op": .string("gaussianBlur"), "radius": .number(sigma)]), extent: recipe.extent) }
+        content = recipe.adding(crop(self.canvas), extent: self.canvas)
+        contentIsUntouched = false
+        contentSource = nil
+    }
+
+    /// The canvas as an image: what was drawn, cut to the canvas.
+    public func makeImage() -> CGImage? {
+        guard let content else {
+            return CGImage(_recipe: _ImageRecipe(source: nil, extent: canvas))
+        }
+        if contentIsUntouched, let contentSource, contentSource.width == width, contentSource.height == height {
+            return contentSource
+        }
+        guard let rendered = content.rendered(in: canvas) else { return nil }
+        return CGImage(_recipe: rendered)
+    }
+
+    // Paths and clipping
+
+    public func addPath(_ path: CGPath) { self.path += path.shapes.map { transformed($0) } }
+    public func addRect(_ rect: CGRect) { path.append(.rect(rect.applying(ctm))) }
+    public func addEllipse(in rect: CGRect) { path.append(.ellipse(rect.applying(ctm))) }
+    public func beginPath() { path = [] }
+    public func closePath() {}
+    public func move(to point: CGPoint) {}
+    public func addLine(to point: CGPoint) {}
+
+    private func transformed(_ shape: CGPath.Shape) -> CGPath.Shape {
+        switch shape {
+        case .rect(let r): .rect(r.applying(ctm))
+        case .ellipse(let r): .ellipse(r.applying(ctm))
+        case .roundedRect(let r, let cw, let ch): .roundedRect(r.applying(ctm), cornerWidth: cw * ctm.a, cornerHeight: ch * ctm.d)
+        }
+    }
+
+    /// Clips to the current path (its first shape) and empties the path.
+    public func clip(using rule: CGPathFillRule = .winding) {
+        if let shape = path.first { clipShape = shape }
+        path = []
+    }
+
+    public func clip(to rect: CGRect) { clipShape = .rect(rect.applying(ctm)) }
+
+    // State and transforms
+
+    public func saveGState() { states.append((ctm, clipShape)) }
+    public func restoreGState() { if let (t, c) = states.popLast() { ctm = t; clipShape = c } }
+    public func translateBy(x: CGFloat, y: CGFloat) { ctm = CGAffineTransform(translationX: x, y: y).concatenating(ctm) }
+    public func scaleBy(x: CGFloat, y: CGFloat) { ctm = CGAffineTransform(scaleX: x, y: y).concatenating(ctm) }
+    public func rotate(by angle: CGFloat) { ctm = CGAffineTransform(rotationAngle: angle).concatenating(ctm) }
+    public func concatenate(_ transform: CGAffineTransform) { ctm = transform.concatenating(ctm) }
+    public var ctm_: CGAffineTransform { ctm }
+    public var userSpaceToDeviceSpaceTransform: CGAffineTransform { ctm }
+
+    // Painting: accepted and not drawn (the page draws bitmaps, not vector paint).
+
+    public func setFillColor(_ color: CGColor) {}
+    public func setStrokeColor(_ color: CGColor) {}
+    public func setLineWidth(_ width: CGFloat) {}
+    public func setLineCap(_ cap: CGLineCap) {}
+    public func setLineJoin(_ join: CGLineJoin) {}
+    public func setAlpha(_ alpha: CGFloat) {}
+    public func setBlendMode(_ mode: CGBlendMode) {}
+    public func setShouldAntialias(_ value: Bool) {}
+    public func setAllowsAntialiasing(_ value: Bool) {}
+    public func fill(_ rect: CGRect) {}
+    public func fill(_ rects: [CGRect]) {}
+    public func fillPath(using rule: CGPathFillRule = .winding) { path = [] }
+    public func strokePath() { path = [] }
+    public func stroke(_ rect: CGRect) {}
+    public func stroke(_ rect: CGRect, width: CGFloat) {}
+    public func fillEllipse(in rect: CGRect) {}
+    public func strokeEllipse(in rect: CGRect) {}
+    public func clear(_ rect: CGRect) {}
+    public func flush() {}
+}

package/Sources/CoreGraphics/ProjectionTransforms.swift

@@ -0,0 +1,28 @@
+// SwiftUI's transforms that take Core Graphics' affine transform. On Apple
+// platforms SwiftUI imports Core Graphics; here Core Graphics builds on the
+// SwiftUI shim, so the conversions live on this side.
+
+import SwiftUI
+
+extension ProjectionTransform {
+    /// The affine transform as a projection: (a b 0 / c d 0 / tx ty 1).
+    public init(_ m: CGAffineTransform) {
+        self.init()
+        (m11, m12, m21, m22, m31, m32) = (m.a, m.b, m.c, m.d, m.tx, m.ty)
+    }
+}
+
+extension CGAffineTransform {
+    /// The affine part of a projection.
+    public init(_ m: ProjectionTransform) {
+        self.init(a: m.m11, b: m.m12, c: m.m21, d: m.m22, tx: m.m31, ty: m.m32)
+    }
+}
+
+nonisolated extension View {
+    /// Draws the view through `transform` about its top-leading corner (an
+    /// offset, a rotation and a scale; a shear draws untransformed).
+    public func transformEffect(_ transform: CGAffineTransform) -> some View {
+        projectionEffect(ProjectionTransform(transform))
+    }
+}