SwiftEntryKit

.package(url: "https://github.com/huri000/SwiftEntryKit", .exact("2.0.0"))

// Customized view
let customView = SomeCustomView()
/*
Do some customization on customView
*/

// Attributes struct that describes the display, style, user interaction and animations of customView.
var attributes = EKAttributes()
/*
Adjust preferable attributes
*/

SwiftEntryKit.display(entry: customView, using: attributes)

var attributes = EKAttributes()

attributes.name = "Top Note"

if SwiftEntryKit.isCurrentlyDisplaying(entryNamed: "Top Note") {
    /* Do your things */
}

attributes.windowLevel = .normal

attributes.position = .bottom

attributes.precedence = .override(priority: .max, dropEnqueuedEntries: false)

attributes.precedence = .enqueue(priority: .normal)

EKAttributes.Precedence.QueueingHeuristic.value = .priority

EKAttributes.Precedence.QueueingHeuristic.value = .chronological

let highPriorityAttributes = EKAttributes()
highPriorityAttributes.precedence.priority = .high

let normalPriorityAttributes = EKAttributes()
normalPriorityAttributes.precedence.priority = .normal

// Display high priority entry
SwiftEntryKit.display(entry: view1, using: highPriorityAttributes)

// Display normal priority entry (ignored!)
SwiftEntryKit.display(entry: view2, using: normalPriorityAttributes)

attributes.displayDuration = 4

attributes.displayDuration = .infinity

let widthConstraint = EKAttributes.PositionConstraints.Edge.ratio(value: 0.9)

let heightConstraint = EKAttributes.PositionConstraints.Edge.intrinsic

attributes.positionConstraints.size = .init(width: widthConstraint, height: heightConstraint)

attributes.positionConstraints.safeArea = .empty(fillSafeArea: false)

attributes.positionConstraints.verticalOffset = 10

attributes.positionConstraints.rotation.isEnabled = false

let offset = EKAttributes.PositionConstraints.KeyboardRelation.Offset(bottom: 10, screenEdgeResistance: 20)
let keyboardRelation = EKAttributes.PositionConstraints.KeyboardRelation.bind(offset: offset)
attributes.positionConstraints.keyboardRelation = keyboardRelation

attributes.entryInteraction = .delayExit(by: 3)

attributes.entryInteraction = .dismiss
attributes.screenInteraction = .dismiss

attributes.entryInteraction = .absorbTouches

attributes.screenInteraction = .forward

let action = {
    // Do something useful
}
attributes.entryInteraction.customTapActions.append(action)

attributes.scroll = .disabled

attributes.scroll = .enabled(swipeable: true, pullbackAnimation: .jolt)

attributes.scroll = .enabled(swipeable: true, pullbackAnimation: .easeOut)

attributes.scroll = .edgeCrossingDisabled(swipeable: true)

attributes.lifecycleEvents.willAppear = {
    // Executed before the entry animates inside 
}

attributes.lifecycleEvents.didAppear = {
    // Executed after the entry animates inside
}

attributes.lifecycleEvents.willDisappear = {
    // Executed before the entry animates outside
}

attributes.lifecycleEvents.didDisappear = {
    // Executed after the entry animates outside
}

attributes.displayMode = .dark

attributes.entryBackground = .clear
attributes.screenBackground = .clear

attributes.entryBackground = .color(color: .standardContent)
attributes.screenBackground = .color(color: EKColor(UIColor(white: 0.5, alpha: 0.5)))

let colors: [EKColor] = ...
attributes.entryBackground = .gradient(gradient: .init(colors: colors, startPoint: .zero, endPoint: CGPoint(x: 1, y: 1)))

attributes.entryBackground = .visualEffect(style: .dark)

attributes.shadow = .active(with: .init(color: .black, opacity: 0.3, radius: 10, offset: .zero))

attributes.shadow = .none

attributes.roundCorners = .top(radius: 10)

attributes.roundCorners = .bottom(radius: 10)

attributes.roundCorners = .all(radius: 10)

attributes.roundCorners = .none

attributes.border = .value(color: .black, width: 0.5)

attributes.border = .none

attributes.entranceAnimation = .init(
                 translate: .init(duration: 0.7, anchorPosition: .top, spring: .init(damping: 1, initialVelocity: 0)), 
                 scale: .init(from: 0.6, to: 1, duration: 0.7), 
                 fade: .init(from: 0.8, to: 1, duration: 0.3))

attributes.popBehavior = .animated(animation: .init(translate: .init(duration: 0.2)))

attributes.popBehavior = .overridden

attributes.statusBar = .light

attributes.statusBar = .hidden

attributes.statusBar = .inferred

public struct EKAttributes

    // Identification
    public var name: String?

    // Display
    public var windowLevel: WindowLevel
    public var position: Position
    public var precedence: Precedence
    public var displayDuration: DisplayDuration
    public var positionConstraints: PositionConstraints

    // User Interaction
    public var screenInteraction: UserInteraction
    public var entryInteraction: UserInteraction
    public var scroll: Scroll
    public var hapticFeedbackType: NotificationHapticFeedback
    public var lifecycleEvents: LifecycleEvents

    // Theme & Style
    public var displayMode = DisplayMode.inferred
    public var entryBackground: BackgroundStyle
    public var screenBackground: BackgroundStyle
    public var shadow: Shadow
    public var roundCorners: RoundCorners
    public var border: Border
    public var statusBar: StatusBar
    
    // Animations
    public var entranceAnimation: Animation
    public var exitAnimation: Animation
    public var popBehavior: PopBehavior
}

// Generate top floating entry and set some properties
var attributes = EKAttributes.topFloat
attributes.entryBackground = .gradient(gradient: .init(colors: [EKColor(.red), EKColor(.green)], startPoint: .zero, endPoint: CGPoint(x: 1, y: 1)))
attributes.popBehavior = .animated(animation: .init(translate: .init(duration: 0.3), scale: .init(from: 1, to: 0.7, duration: 0.7)))
attributes.shadow = .active(with: .init(color: .black, opacity: 0.5, radius: 10, offset: .zero))
attributes.statusBar = .dark
attributes.scroll = .enabled(swipeable: true, pullbackAnimation: .jolt)
attributes.positionConstraints.maxSize = .init(width: .constant(value: UIScreen.main.minEdge), height: .intrinsic)

let title = EKProperty.LabelContent(text: titleText, style: .init(font: titleFont, color: textColor))
let description = EKProperty.LabelContent(text: descText, style: .init(font: descFont, color: textColor))
let image = EKProperty.ImageContent(image: UIImage(named: imageName)!, size: CGSize(width: 35, height: 35))
let simpleMessage = EKSimpleMessage(image: image, title: title, description: description)
let notificationMessage = EKNotificationMessage(simpleMessage: simpleMessage)

let contentView = EKNotificationMessageView(with: notificationMessage)
SwiftEntryKit.display(entry: contentView, using: attributes)

// Create a basic toast that appears at the top
var attributes = EKAttributes.topToast

// Set its background to white
attributes.entryBackground = .color(color: .white)

// Animate in and out using default translation
attributes.entranceAnimation = .translation
attributes.exitAnimation = .translation

let customView = UIView()
/*
... Customize the view as you like ...
*/

// Display the view with the configuration
SwiftEntryKit.display(entry: customView, using: attributes)

SwiftEntryKit.display(entry: customViewController, using: attributes)

SwiftEntryKit.display(entry: view, using: attributes, rollbackWindow: .custom(window: alternativeWindow))

SwiftEntryKit.dismiss()

SwiftEntryKit.dismiss(.displayed)

SwiftEntryKit.dismiss(.all)

SwiftEntryKit.dismiss(.queue)

SwiftEntryKit.dismiss(.specific(entryName: "Entry Name"))

SwiftEntryKit.dismiss(.prioritizedLowerOrEqualTo(priority: .normal))

SwiftEntryKit.dismiss {
    // Executed right after the entry has been dismissed
}

if SwiftEntryKit.isCurrentlyDisplaying {
    /* Do your things */
}

if SwiftEntryKit.isCurrentlyDisplaying(entryNamed: "Top Note") {
/* Do your things */
}

if SwiftEntryKit.isQueueEmpty {
    /* Do your things */
}

if SwiftEntryKit.queueContains(entryNamed: "Custom-Name") {
    /* Do your things */
}

attributes.scroll = .enabled(swipeable: true, pullbackAnimation: .easeOut)

attributes.scroll = .enabled(swipeable: true, pullbackAnimation: .jolt)

var attributes = EKAttributes.topFloat

// Give the entry the width of the screen minus 20pts from each side, the height is decided by the content's contraint's
attributes.positionConstraints.size = .init(width: .offset(value: 20), height: .intrinsic)

// Give the entry maximum width of the screen minimum edge - thus the entry won't grow much when the device orientation changes from portrait to landscape mode.
let edgeWidth = min(UIScreen.main.bounds.width, UIScreen.main.bounds.height)
attributes.positionConstraints.maxSize = .init(width: .constant(value: edgeWidth), height: .intrinsic)

let customView = UIView()
/*
... Customize the view as you like ...
*/

// Use class method of SwiftEntryKit to display the view using the desired attributes
SwiftEntryKit.display(entry: customView, using: attributes)