fastevent 1.1.2 → 2.0.0

package/packages/turbo/src/event.zig

@@ -1,251 +0,0 @@
-const std = @import("std");
-const types = @import("types.zig");
-const Allocator = std.mem.Allocator;
-
-const EventListener = types.EventListener;
-const EventMessage = types.EventMessage;
-const ListenOptions = types.ListenOptions;
-const Subscriber = types.Subscriber;
-const EventOptions = types.EventOptions;
-const ListenerNode = types.ListenerNode;
-const ListenerEntry = types.ListenerEntry;
-
-/// 事件发射器
-pub const EventEmitter = struct {
-    allocator: Allocator,
-    options: EventOptions,
-    root: *ListenerNode,
-    retained_events: std.StringHashMap(std.ArrayList(EventMessage)),
-
-    pub fn init(allocator: Allocator, options: EventOptions) !*EventEmitter {
-        const emitter = try allocator.create(EventEmitter);
-        emitter.* = .{
-            .allocator = allocator,
-            .options = options,
-            .root = try ListenerNode.init(allocator),
-            .retained_events = std.StringHashMap(std.ArrayList(EventMessage)).init(allocator),
-        };
-        return emitter;
-    }
-
-    pub fn deinit(self: *EventEmitter) void {
-        var it = self.retained_events.iterator();
-        while (it.next()) |entry| {
-            entry.value_ptr.deinit();
-        }
-        self.retained_events.deinit();
-        self.root.deinit();
-        self.allocator.destroy(self.root);
-        self.allocator.destroy(self);
-    }
-
-    /// 添加事件监听器
-    pub fn on(self: *EventEmitter, event_type: []const u8, listener: EventListener, options: ListenOptions) !*Subscriber {
-        const path = try self.splitEventPath(event_type);
-        defer self.allocator.free(path);
-
-        var node = self.root;
-        for (path) |segment| {
-            var child = node.children.get(segment) orelse {
-                const new_node = try ListenerNode.init(self.allocator);
-                try node.children.put(segment, new_node);
-                new_node;
-            };
-            node = child;
-        }
-
-        const entry = if (options.count > 0)
-            ListenerEntry{ .Counted = .{ .listener = listener, .count = options.count } }
-        else
-            ListenerEntry{ .Simple = listener };
-
-        if (options.prepend) {
-            try node.listeners.insert(0, entry);
-        } else {
-            try node.listeners.append(entry);
-        }
-
-        if (self.options.on_add_listener) |callback| {
-            callback(path, listener);
-        }
-
-        // 处理保留的事件
-        if (self.retained_events.get(event_type)) |events| {
-            for (events.items) |msg| {
-                _ = try self.executeListener(listener, &msg);
-            }
-        }
-
-        const subscriber = try self.allocator.create(Subscriber);
-        subscriber.* = .{
-            .off_fn = struct {
-                fn off(sub: *Subscriber) void {
-                    self.off(event_type, listener);
-                    self.allocator.destroy(sub);
-                }
-            }.off,
-        };
-
-        return subscriber;
-    }
-
-    /// 移除事件监听器
-    pub fn off(self: *EventEmitter, event_type: []const u8, listener: ?EventListener) void {
-        const path = self.splitEventPath(event_type) catch return;
-        defer self.allocator.free(path);
-
-        if (self.options.on_remove_listener) |callback| {
-            if (listener) |l| {
-                callback(path, l);
-            }
-        }
-
-        var node = self.root;
-        var nodes = std.ArrayList(*ListenerNode).init(self.allocator);
-        defer nodes.deinit();
-
-        // 找到目标节点
-        for (path) |segment| {
-            if (node.children.get(segment)) |child| {
-                try nodes.append(node);
-                node = child;
-            } else {
-                return;
-            }
-        }
-
-        // 移除监听器
-        if (listener) |l| {
-            var i: usize = 0;
-            while (i < node.listeners.items.len) {
-                const entry = node.listeners.items[i];
-                const current = switch (entry) {
-                    .Simple => |simple| simple,
-                    .Counted => |counted| counted.listener,
-                };
-                if (current == l) {
-                    _ = node.listeners.orderedRemove(i);
-                } else {
-                    i += 1;
-                }
-            }
-        } else {
-            node.listeners.clearRetainingCapacity();
-        }
-
-        // 清理空节点
-        if (node.listeners.items.len == 0 and node.children.count() == 0) {
-            var i: usize = nodes.items.len;
-            while (i > 0) : (i -= 1) {
-                const parent = nodes.items[i - 1];
-                const segment = path[i - 1];
-                _ = parent.children.remove(segment);
-                if (parent.listeners.items.len > 0 or parent.children.count() > 0) {
-                    break;
-                }
-            }
-        }
-    }
-
-    /// 触发事件
-    pub fn emit(self: *EventEmitter, event_type: []const u8, payload: ?*anyopaque, meta: ?std.StringHashMap([]const u8)) !void {
-        var message = EventMessage.init(event_type, payload, meta);
-        const path = try self.splitEventPath(event_type);
-        defer self.allocator.free(path);
-
-        var results = std.ArrayList(anyerror!void).init(self.allocator);
-        defer results.deinit();
-
-        var listeners = std.ArrayList(EventListener).init(self.allocator);
-        defer listeners.deinit();
-
-        try self.collectListeners(self.root, path, 0, &listeners);
-
-        for (listeners.items) |listener| {
-            const result = self.executeListener(listener, &message);
-            try results.append(result);
-        }
-
-        if (self.options.on_execute_listener) |callback| {
-            callback(&message, results.items, listeners.items);
-        }
-    }
-
-    /// 保留事件
-    pub fn retain(self: *EventEmitter, event_type: []const u8, payload: ?*anyopaque, meta: ?std.StringHashMap([]const u8)) !void {
-        var events = self.retained_events.get(event_type) orelse {
-            var list = std.ArrayList(EventMessage).init(self.allocator);
-            try self.retained_events.put(event_type, list);
-            list;
-        };
-        try events.append(EventMessage.init(event_type, payload, meta));
-        try self.emit(event_type, payload, meta);
-    }
-
-    /// 释放保留的事件
-    pub fn release(self: *EventEmitter, event_type: []const u8) void {
-        if (self.retained_events.get(event_type)) |events| {
-            events.deinit();
-            _ = self.retained_events.remove(event_type);
-        }
-    }
-
-    // 内部辅助函数
-
-    fn splitEventPath(self: *EventEmitter, event_type: []const u8) ![][]const u8 {
-        var list = std.ArrayList([]const u8).init(self.allocator);
-        var it = std.mem.split(u8, event_type, self.options.delimiter);
-        while (it.next()) |segment| {
-            try list.append(segment);
-        }
-        return list.toOwnedSlice();
-    }
-
-    fn executeListener(self: *EventEmitter, listener: EventListener, message: *EventMessage) anyerror!void {
-        if (self.options.ignore_errors) {
-            listener(message) catch |err| {
-                if (self.options.on_listener_error) |callback| {
-                    callback(message.type, err);
-                }
-            };
-        } else {
-            try listener(message);
-        }
-    }
-
-    fn collectListeners(self: *EventEmitter, node: *ListenerNode, path: [][]const u8, depth: usize, result: *std.ArrayList(EventListener)) !void {
-        // 添加当前节点的监听器
-        for (node.listeners.items) |*entry| {
-            switch (entry.*) {
-                .Simple => |listener| try result.append(listener),
-                .Counted => |*counted| {
-                    if (counted.count > 0) {
-                        try result.append(counted.listener);
-                        counted.count -= 1;
-                        if (counted.count == 0) {
-                            // 移除用完的监听器
-                            for (node.listeners.items, 0..) |e, i| {
-                                if (std.meta.activeTag(e) == .Counted and &e.Counted == counted) {
-                                    _ = node.listeners.orderedRemove(i);
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                },
-            }
-        }
-
-        if (depth >= path.len) return;
-
-        // 处理通配符
-        if (node.children.get("*")) |wildcard| {
-            try self.collectListeners(wildcard, path, depth + 1, result);
-        }
-
-        // 处理具体路径
-        if (node.children.get(path[depth])) |child| {
-            try self.collectListeners(child, path, depth + 1, result);
-        }
-    }
-};

package/packages/turbo/src/index.zig

@@ -1,70 +0,0 @@
-//! FastEvent是一个高性能的事件系统，支持事件监听、触发、作用域管理和通配符匹配等功能。
-//! 它使用Zig语言实现，提供了类型安全和内存安全的事件处理机制。
-
-pub const types = @import("types.zig");
-pub const event = @import("event.zig");
-pub const scope = @import("scope.zig");
-pub const utils = @import("utils.zig");
-
-// 重导出常用类型
-pub const EventEmitter = event.EventEmitter;
-pub const EventScope = scope.EventScope;
-pub const EventMessage = types.EventMessage;
-pub const EventListener = types.EventListener;
-pub const ListenOptions = types.ListenOptions;
-pub const Subscriber = types.Subscriber;
-pub const EventOptions = types.EventOptions;
-
-// 重导出常用函数
-pub const createRootScope = scope.createRootScope;
-
-/// 创建一个新的事件发射器
-pub fn createEmitter(allocator: @import("std").mem.Allocator, options: EventOptions) !*EventEmitter {
-    return EventEmitter.init(allocator, options);
-}
-
-test {
-    // 运行所有测试
-    @import("std").testing.refAllDecls(@This());
-}
-
-/// 使用示例
-const example = @"
-// 创建事件发射器
-var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-defer _ = gpa.deinit();
-const allocator = gpa.allocator();
-
-// 配置选项
-const options = EventOptions{
-    .debug = true,
-    .delimiter = '/',
-};
-
-// 创建发射器
-var emitter = try createEmitter(allocator, options);
-defer emitter.deinit();
-
-// 创建根作用域
-var root_scope = try createRootScope(allocator, emitter);
-defer root_scope.deinit();
-
-// 添加事件监听器
-try root_scope.on('user/login', userLoginHandler, .{});
-
-// 触发事件
-try emitter.emit('user/login', userInfo, null);
-
-// 使用通配符监听
-try root_scope.on('user/*', anyUserEventHandler, .{});
-
-// 创建子作用域
-var sub_scope = try root_scope.createScope();
-defer sub_scope.deinit();
-
-// 在子作用域中添加监听器
-try sub_scope.on('chat/message', chatMessageHandler, .{});
-
-// 当不再需要时，dispose()会自动清理所有监听器
-sub_scope.dispose();
-";

package/packages/turbo/src/scope.zig

@@ -1,104 +0,0 @@
-const std = @import("std");
-const types = @import("types.zig");
-const event = @import("event.zig");
-
-const Allocator = std.mem.Allocator;
-const EventEmitter = event.EventEmitter;
-const Subscriber = types.Subscriber;
-const EventListener = types.EventListener;
-const ListenOptions = types.ListenOptions;
-
-/// 事件作用域，用于管理一组相关的事件监听器
-pub const EventScope = struct {
-    allocator: Allocator,
-    emitter: *EventEmitter,
-    subscribers: std.ArrayList(*Subscriber),
-    is_disposed: bool,
-
-    pub fn init(allocator: Allocator, emitter: *EventEmitter) !*EventScope {
-        const scope = try allocator.create(EventScope);
-        scope.* = .{
-            .allocator = allocator,
-            .emitter = emitter,
-            .subscribers = std.ArrayList(*Subscriber).init(allocator),
-            .is_disposed = false,
-        };
-        return scope;
-    }
-
-    pub fn deinit(self: *EventScope) void {
-        self.dispose();
-        self.subscribers.deinit();
-        self.allocator.destroy(self);
-    }
-
-    /// 在作用域中添加事件监听器
-    pub fn on(self: *EventScope, event_type: []const u8, listener: EventListener, options: ListenOptions) !void {
-        if (self.is_disposed) return error.ScopeDisposed;
-
-        const subscriber = try self.emitter.on(event_type, listener, options);
-        try self.subscribers.append(subscriber);
-    }
-
-    /// 移除作用域中的特定事件监听器
-    pub fn off(self: *EventScope, event_type: []const u8, listener: EventListener) void {
-        if (self.is_disposed) return;
-
-        self.emitter.off(event_type, listener);
-
-        // 移除对应的订阅者
-        var i: usize = 0;
-        while (i < self.subscribers.items.len) {
-            const subscriber = self.subscribers.items[i];
-            // 注意：这里的比较可能不够准确，因为我们无法直接比较函数指针
-            // 在实际应用中可能需要更复杂的机制来匹配订阅者
-            if (@ptrToInt(subscriber.off_fn) == @ptrToInt(listener)) {
-                _ = self.subscribers.orderedRemove(i);
-                self.allocator.destroy(subscriber);
-            } else {
-                i += 1;
-            }
-        }
-    }
-
-    /// 清理作用域中的所有事件监听器
-    pub fn dispose(self: *EventScope) void {
-        if (self.is_disposed) return;
-        self.is_disposed = true;
-
-        // 移除所有订阅者
-        for (self.subscribers.items) |subscriber| {
-            subscriber.off();
-            self.allocator.destroy(subscriber);
-        }
-        self.subscribers.clearRetainingCapacity();
-    }
-
-    /// 创建子作用域
-    pub fn createScope(self: *EventScope) !*EventScope {
-        if (self.is_disposed) return error.ScopeDisposed;
-
-        const child_scope = try EventScope.init(self.allocator, self.emitter);
-        const subscriber = try self.allocator.create(Subscriber);
-        subscriber.* = .{
-            .off_fn = struct {
-                fn off(sub: *Subscriber) void {
-                    child_scope.dispose();
-                    child_scope.allocator.destroy(sub);
-                }
-            }.off,
-        };
-        try self.subscribers.append(subscriber);
-        return child_scope;
-    }
-
-    /// 检查作用域是否已被清理
-    pub fn isDisposed(self: *const EventScope) bool {
-        return self.is_disposed;
-    }
-};
-
-/// 创建根作用域
-pub fn createRootScope(allocator: Allocator, emitter: *EventEmitter) !*EventScope {
-    return EventScope.init(allocator, emitter);
-}

package/packages/turbo/src/types.zig

@@ -1,88 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-/// 事件监听器函数类型
-pub const EventListener = *const fn (message: *EventMessage) anyerror!void;
-
-/// 事件消息结构
-pub const EventMessage = struct {
-    type: []const u8,
-    payload: ?*anyopaque,
-    meta: ?std.StringHashMap([]const u8),
-
-    pub fn init(type: []const u8, payload: ?*anyopaque, meta: ?std.StringHashMap([]const u8)) EventMessage {
-        return .{
-            .type = type,
-            .payload = payload,
-            .meta = meta,
-        };
-    }
-};
-
-/// 事件监听选项
-pub const ListenOptions = struct {
-    count: usize = 0, // 0表示无限次数
-    prepend: bool = false,
-};
-
-/// 事件订阅者接口
-pub const Subscriber = struct {
-    off_fn: *const fn () void,
-
-    pub fn off(self: *const Subscriber) void {
-        self.off_fn();
-    }
-};
-
-/// 事件选项
-pub const EventOptions = struct {
-    debug: bool = false,
-    id: []const u8 = undefined,
-    delimiter: []const u8 = "/",
-    context: ?*anyopaque = null,
-    ignore_errors: bool = true,
-    meta: ?std.StringHashMap([]const u8) = null,
-
-    // 回调函数
-    on_add_listener: ?*const fn (path: []const []const u8, listener: EventListener) void = null,
-    on_remove_listener: ?*const fn (path: []const []const u8, listener: EventListener) void = null,
-    on_clear_listeners: ?*const fn () void = null,
-    on_listener_error: ?*const fn (event_type: []const u8, err: anyerror) void = null,
-    on_execute_listener: ?*const fn (message: *EventMessage, results: []const anyerror!void, listeners: []const EventListener) void = null,
-};
-
-/// 监听器节点结构
-pub const ListenerNode = struct {
-    listeners: std.ArrayList(ListenerEntry),
-    children: std.StringHashMap(*ListenerNode),
-    allocator: Allocator,
-
-    pub fn init(allocator: Allocator) !*ListenerNode {
-        const node = try allocator.create(ListenerNode);
-        node.* = .{
-            .listeners = std.ArrayList(ListenerEntry).init(allocator),
-            .children = std.StringHashMap(*ListenerNode).init(allocator),
-            .allocator = allocator,
-        };
-        return node;
-    }
-
-    pub fn deinit(self: *ListenerNode) void {
-        var it = self.children.iterator();
-        while (it.next()) |entry| {
-            entry.value_ptr.*.deinit();
-            self.allocator.destroy(entry.value_ptr.*);
-        }
-        self.children.deinit();
-        self.listeners.deinit();
-    }
-};
-
-/// 监听器条目，可以是普通监听器或带计数的监听器
-pub const ListenerEntry = union(enum) {
-    Simple: EventListener,
-    Counted: struct {
-        listener: EventListener,
-        count: usize,
-    },
-};

package/packages/turbo/src/utils.zig

@@ -1,171 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-/// 检查字符串是否包含通配符
-pub fn hasWildcard(str: []const u8) bool {
-    return std.mem.indexOf(u8, str, "*") != null;
-}
-
-/// 将事件类型字符串分割为路径段
-pub fn splitEventPath(allocator: Allocator, event_type: []const u8, delimiter: []const u8) ![][]const u8 {
-    var list = std.ArrayList([]const u8).init(allocator);
-    errdefer list.deinit();
-
-    var it = std.mem.split(u8, event_type, delimiter);
-    while (it.next()) |segment| {
-        const owned_segment = try allocator.dupe(u8, segment);
-        errdefer allocator.free(owned_segment);
-        try list.append(owned_segment);
-    }
-
-    return list.toOwnedSlice();
-}
-
-/// 释放splitEventPath返回的路径段数组
-pub fn freeEventPath(allocator: Allocator, path: [][]const u8) void {
-    for (path) |segment| {
-        allocator.free(segment);
-    }
-    allocator.free(path);
-}
-
-/// 将路径段合并为事件类型字符串
-pub fn joinEventPath(allocator: Allocator, path: []const []const u8, delimiter: []const u8) ![]u8 {
-    if (path.len == 0) return allocator.dupe(u8, "");
-
-    // 计算所需的总长度
-    var total_len: usize = 0;
-    for (path) |segment| {
-        total_len += segment.len;
-    }
-    total_len += delimiter.len * (path.len - 1);
-
-    // 分配内存并构建结果
-    const result = try allocator.alloc(u8, total_len);
-    errdefer allocator.free(result);
-
-    var pos: usize = 0;
-    for (path, 0..) |segment, i| {
-        std.mem.copy(u8, result[pos..], segment);
-        pos += segment.len;
-        if (i < path.len - 1) {
-            std.mem.copy(u8, result[pos..], delimiter);
-            pos += delimiter.len;
-        }
-    }
-
-    return result;
-}
-
-/// 检查事件类型是否匹配模式
-pub fn matchEventType(event_type: []const u8, pattern: []const u8, delimiter: []const u8) bool {
-    // 如果模式中没有通配符，直接比较字符串
-    if (!hasWildcard(pattern)) {
-        return std.mem.eql(u8, event_type, pattern);
-    }
-
-    var event_it = std.mem.split(u8, event_type, delimiter);
-    var pattern_it = std.mem.split(u8, pattern, delimiter);
-
-    // 逐段比较
-    while (true) {
-        const event_segment = event_it.next();
-        const pattern_segment = pattern_it.next();
-
-        // 如果两个迭代器都结束了，说明完全匹配
-        if (event_segment == null and pattern_segment == null) {
-            return true;
-        }
-
-        // 如果其中一个迭代器结束了但另一个没有，说明不匹配
-        if (event_segment == null or pattern_segment == null) {
-            return false;
-        }
-
-        // 如果当前段是通配符，继续下一段
-        if (std.mem.eql(u8, pattern_segment.?, "*")) {
-            continue;
-        }
-
-        // 比较当前段
-        if (!std.mem.eql(u8, event_segment.?, pattern_segment.?)) {
-            return false;
-        }
-    }
-}
-
-/// 创建调试信息
-pub fn createDebugInfo(allocator: Allocator, event_type: []const u8, payload: ?*anyopaque) ![]u8 {
-    var debug_info = std.ArrayList(u8).init(allocator);
-    errdefer debug_info.deinit();
-
-    try debug_info.writer().print("Event: {s}\n", .{event_type});
-    if (payload) |p| {
-        try debug_info.writer().print("Payload: {*}\n", .{p});
-    } else {
-        try debug_info.appendSlice("Payload: null\n");
-    }
-
-    return debug_info.toOwnedSlice();
-}
-
-/// 检查路径是否有效
-pub fn isValidPath(path: []const []const u8) bool {
-    if (path.len == 0) return false;
-
-    for (path) |segment| {
-        if (segment.len == 0) return false;
-        if (std.mem.indexOf(u8, segment, "/") != null) return false;
-    }
-
-    return true;
-}
-
-test "utils - hasWildcard" {
-    try std.testing.expect(hasWildcard("foo*"));
-    try std.testing.expect(hasWildcard("foo/*/bar"));
-    try std.testing.expect(!hasWildcard("foo/bar"));
-}
-
-test "utils - splitEventPath" {
-    const allocator = std.testing.allocator;
-
-    const path = try splitEventPath(allocator, "foo/bar/baz", "/");
-    defer freeEventPath(allocator, path);
-
-    try std.testing.expectEqual(@as(usize, 3), path.len);
-    try std.testing.expectEqualStrings("foo", path[0]);
-    try std.testing.expectEqualStrings("bar", path[1]);
-    try std.testing.expectEqualStrings("baz", path[2]);
-}
-
-test "utils - joinEventPath" {
-    const allocator = std.testing.allocator;
-
-    const segments = [_][]const u8{ "foo", "bar", "baz" };
-    const result = try joinEventPath(allocator, &segments, "/");
-    defer allocator.free(result);
-
-    try std.testing.expectEqualStrings("foo/bar/baz", result);
-}
-
-test "utils - matchEventType" {
-    try std.testing.expect(matchEventType("foo/bar/baz", "foo/*/baz", "/"));
-    try std.testing.expect(matchEventType("foo/bar/baz", "foo/bar/baz", "/"));
-    try std.testing.expect(!matchEventType("foo/bar/baz", "foo/bar", "/"));
-    try std.testing.expect(!matchEventType("foo/bar", "foo/bar/baz", "/"));
-}
-
-test "utils - isValidPath" {
-    const segments1 = [_][]const u8{ "foo", "bar", "baz" };
-    try std.testing.expect(isValidPath(&segments1));
-
-    const segments2 = [_][]const u8{ "foo", "", "baz" };
-    try std.testing.expect(!isValidPath(&segments2));
-
-    const segments3 = [_][]const u8{ "foo", "bar/baz" };
-    try std.testing.expect(!isValidPath(&segments3));
-
-    const segments4 = [_][]const u8{};
-    try std.testing.expect(!isValidPath(&segments4));
-}