Feat: initial implementation 🚀

Package.swift

@@ -5,6 +5,7 @@ import PackageDescription
 
 let package = Package(
     name: "TranslucentWindowStyle",
+    platforms: [.macOS(.v13)],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(

README.md

@@ -1,3 +1,86 @@
 # TranslucentWindowStyle
 
-A description of this package.
+Translucent Window Background Style is a Swift package with a custom SwiftUI window background style that creates a translucent window with a blur effect. This package allows you to add a translucent background style to your SwiftUI app's windows.
+
+## Overview
+
+The Translucent Window Background Style package provides a `TranslucentBackgroundStyle` struct that conforms to the `WindowBackgroundStyle` protocol. This style creates a translucent window with a blur effect.
+
+## Usage
+
+To use the Translucent Window Background Style in your SwiftUI app, follow these steps:
+
+1. Import the package in your SwiftUI view file:
+
+   ```swift
+   import TranslucentWindowBackgroundStyle
+   ```
+
+2. Apply the `presentedWindowBackgroundStyle` modifier to your window view, and pass in an instance of `TranslucentBackgroundStyle`:
+
+   ```swift
+   WindowGroup {
+       ContentView()
+          .presentedWindowBackgroundStyle(TranslucentBackgroundStyle.hiddenTitleBarTranslucent)
+   }
+   ```
+
+3. The `hiddenTitleBarTranslucent` static property of `TranslucentBackgroundStyle` provides a convenient method to create a translucent window without a title bar.
+
+   ```swift
+   TranslucentBackgroundStyle.hiddenTitleBarTranslucent
+   ```
+
+### Example
+
+![screenshot](screenshot.png)
+
+## Installation
+
+The Translucent Window Background Style package can be installed via Swift Package Manager. To install, follow these steps:
+
+1. Open your project in Xcode.
+
+2. Click on File > Swift Packages > Add Package Dependency.
+
+3. Enter the following URL in the search bar:
+
+   ```javascript
+   https://github.com/DominatorVbN/TranslucentWindowBackgroundStyle
+   ```
+
+   Replace "your-username" with your GitHub username or the URL of your forked repository.
+
+4. Choose the version or branch of the package that you want to install.
+
+5. Click on the Add Package button.
+
+6. Add `TranslucentWindowBackgroundStyle` to the list of dependencies for your target in your project's `Package.swift` file:
+
+   ```swift
+   dependencies: [
+       .package(url: "https://github.com/DominatorVbN/TranslucentWindowBackgroundStyle", .upToNextMinor(from: "1.0.0"))
+   ]
+   ```
+
+   Replace "your-username" with your GitHub username or the URL of your forked repository, and "1.0.0" with the version or branch that you installed.
+
+7. Import the package in your SwiftUI view file:
+
+   ```swift
+   import TranslucentWindowBackgroundStyle
+   ```
+
+8. You're now ready to use the Translucent Window Background Style in your SwiftUI app!
+
+## Contributing
+
+Contributions are always welcome, whether it's bug fixes, feature enhancements, or documentation improvements. To contribute, please follow these steps:
+
+1. Fork the repository
+2. Create a new branch for your changes: `git checkout -b feature/your-feature-name`
+3. Make your changes and commit them: `git commit -m 'Add some feature'`
+4. Push your changes to your forked repository: `git push origin feature/your-feature-name`
+5. Create a pull request on the original repository, with a description of your changes
+
+Thank you for your contributions!

Sources/TranslucentWindowStyle/TranslucentWindowStyle.swift

@@ -1,6 +1,171 @@
-public struct TranslucentWindowStyle {
-    public private(set) var text = "Hello, World!"
+import SwiftUI
 
-    public init() {
+
+public protocol WindowBackgroundStyle {
+    associatedtype Body : View
+    @ViewBuilder @MainActor var backgroud: Self.Body { get }
+}
+
+extension WindowBackgroundStyle where Self == TranslucentBackgroundStyle {
+    public static var hiddenTitleBar: TranslucentBackgroundStyle { TranslucentBackgroundStyle() }
+}
+
+public struct TranslucentBackgroundStyle: WindowBackgroundStyle {
+    public var backgroud: some View {
+        TranslucentWindowBackground()
     }
 }
+
+extension View {
+
+    @MainActor public func presentedWindowBackgroundStyle<S>(_ style: S) -> some View where S : WindowBackgroundStyle {
+        self.background(style.backgroud)
+    }
+
+}
+
+struct TranslucentWindowBackground: NSViewRepresentable {
+
+    enum ContentViewConfiguration {
+        case embed(NSView?)
+        case replace(NSView?)
+    }
+
+    enum StyleMaskConfiguration {
+        case insert(NSWindow.StyleMask)
+        case replace(NSWindow.StyleMask)
+    }
+
+    struct WindowConfiguration {
+        let isOpaque: Bool
+        let backgroundColor: NSColor
+        let contentViewCofiguration: ContentViewConfiguration
+        let styleMaskConfiguration: StyleMaskConfiguration
+        let titlebarAppearsTransparent: Bool
+        let titleVisibility: NSWindow.TitleVisibility
+        let standardWindowButtonConfig: StandardWindowButtonConfiguration
+        let isMovableByWindowBackground: Bool
+
+        public struct StandardWindowButtonConfiguration {
+            let miniaturizeButtonIsHidden: Bool
+            let closeButtonIsHidden: Bool
+            let zoomButtonIsHidden: Bool
+        }
+
+        static func getTranlucentBackground() -> NSView {
+            let visualEffect = NSVisualEffectView()
+            visualEffect.blendingMode = .behindWindow
+            visualEffect.state = .followsWindowActiveState
+            visualEffect.material = .sidebar
+            return visualEffect
+        }
+
+        static let translucent: WindowConfiguration = WindowConfiguration(
+            isOpaque: false,
+            backgroundColor: NSColor.clear,
+            contentViewCofiguration: .embed(getTranlucentBackground()),
+            styleMaskConfiguration: .insert(.titled),
+            titlebarAppearsTransparent: true,
+            titleVisibility: .hidden,
+            standardWindowButtonConfig: StandardWindowButtonConfiguration(
+                miniaturizeButtonIsHidden: true,
+                closeButtonIsHidden: true,
+                zoomButtonIsHidden: true
+            ),
+            isMovableByWindowBackground: true
+        )
+
+        static func configure(window: NSWindow, forConfig config: WindowConfiguration) {
+
+            window.isOpaque = config.isOpaque
+            window.backgroundColor = config.backgroundColor
+
+            switch config.contentViewCofiguration {
+            case let .replace(view):
+                window.contentView = view
+            case let .embed(view):
+                let currentContentView = window.contentView
+                window.contentView = view
+                if let currentContentView = currentContentView {
+                    view?.addSubview(currentContentView)
+                }
+            }
+
+            switch config.styleMaskConfiguration {
+            case let .replace(mask):
+                window.styleMask = mask
+            case let .insert(mask):
+                window.styleMask.insert(mask)
+            }
+
+            window.titlebarAppearsTransparent = config.titlebarAppearsTransparent
+            window.titleVisibility = config.titleVisibility
+            window.standardWindowButton(.miniaturizeButton)?.isHidden = config.standardWindowButtonConfig.miniaturizeButtonIsHidden
+            window.standardWindowButton(.closeButton)?.isHidden = config.standardWindowButtonConfig.closeButtonIsHidden
+            window.standardWindowButton(.zoomButton)?.isHidden = config.standardWindowButtonConfig.zoomButtonIsHidden
+            window.isMovableByWindowBackground = config.isMovableByWindowBackground
+        }
+    }
+
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator()
+    }
+
+
+    class Coordinator: NSObject {
+        private var _originalWindowConfiguration: WindowConfiguration?
+
+        func createWindowConfigurationForCurrentContext(_ context: NSWindow) -> WindowConfiguration {
+            WindowConfiguration(
+                isOpaque: context.isOpaque,
+                backgroundColor: context.backgroundColor,
+                contentViewCofiguration: .replace(context.contentView),
+                styleMaskConfiguration: .replace(context.styleMask),
+                titlebarAppearsTransparent: context.titlebarAppearsTransparent,
+                titleVisibility: context.titleVisibility,
+                standardWindowButtonConfig: WindowConfiguration.StandardWindowButtonConfiguration(
+                    miniaturizeButtonIsHidden: context.standardWindowButton(.miniaturizeButton)?.isHidden ?? false,
+                    closeButtonIsHidden: context.standardWindowButton(.closeButton)?.isHidden ?? false,
+                    zoomButtonIsHidden: context.standardWindowButton(.zoomButton)?.isHidden ?? false
+                ),
+                isMovableByWindowBackground: context.isMovableByWindowBackground
+            )
+        }
+
+        func makeWindowTranslucent(window: NSWindow?) {
+            guard let window = window else { return }
+            self._originalWindowConfiguration = createWindowConfigurationForCurrentContext(window)
+            let translucentWindowConfiguration = WindowConfiguration.translucent
+            WindowConfiguration.configure(window: window, forConfig: translucentWindowConfiguration)
+        }
+
+        func resetWindow(window: NSWindow) {
+            if let originalWindowConfiguration = _originalWindowConfiguration {
+                WindowConfiguration.configure(window: window, forConfig: originalWindowConfiguration)
+            }
+        }
+    }
+
+    func makeNSView(context: Context) -> NSView {
+        let view = NSView()
+        DispatchQueue.main.async {
+            let window = view.window
+            context.coordinator.makeWindowTranslucent(window: window)
+        }
+        return view
+    }
+
+    func updateNSView(_ nsView: NSView, context: Context) {
+
+    }
+
+    static func dismantleNSView(_ nsView: NSView, coordinator: Coordinator) {
+        guard let window = nsView.window else {
+            return
+        }
+        coordinator.resetWindow(window: window)
+    }
+}
+
+

Tests/TranslucentWindowStyleTests/TranslucentWindowStyleTests.swift

@@ -2,10 +2,4 @@ import XCTest
 @testable import TranslucentWindowStyle
 
 final class TranslucentWindowStyleTests: XCTestCase {
-    func testExample() throws {
-        // This is an example of a functional test case.
-        // Use XCTAssert and related functions to verify your tests produce the correct
-        // results.
-        XCTAssertEqual(TranslucentWindowStyle().text, "Hello, World!")
-    }
 }