implement publicHoistPattern and hoistPattern

src/api/schema.zig

@@ -3061,6 +3061,9 @@ pub const api = struct {
 
         minimum_release_age_ms: ?f64 = null,
         minimum_release_age_excludes: ?[]const []const u8 = null,
+
+        public_hoist_pattern: ?install.PnpmMatcher = null,
+        hoist_pattern: ?install.PnpmMatcher = null,
     };
 
     pub const ClientServerModule = struct {
@@ -3223,4 +3226,5 @@ const std = @import("std");
 
 const bun = @import("bun");
 const OOM = bun.OOM;
+const install = bun.install;
 const js_ast = bun.ast;

src/bun.js/bindings/RegularExpression.zig

@@ -19,11 +19,11 @@ pub const RegularExpression = opaque {
     extern fn Yarr__RegularExpression__searchRev(this: *RegularExpression) i32;
     extern fn Yarr__RegularExpression__matches(this: *RegularExpression, string: bun.String) i32;
 
-    pub inline fn init(pattern: bun.String, flags: Flags) !*RegularExpression {
+    pub inline fn init(pattern: bun.String, flags: Flags) error{InvalidRegExp}!*RegularExpression {
         var regex = Yarr__RegularExpression__init(pattern, @intFromEnum(flags));
         if (!regex.isValid()) {
             regex.deinit();
-            return error.InvalidRegex;
+            return error.InvalidRegExp;
         }
         return regex;
     }

src/bun.js/jsc.zig

@@ -85,6 +85,7 @@ pub const SourceProvider = @import("./bindings/SourceProvider.zig").SourceProvid
 pub const CatchScope = @import("./bindings/CatchScope.zig").CatchScope;
 pub const ExceptionValidationScope = @import("./bindings/CatchScope.zig").ExceptionValidationScope;
 pub const MarkedArgumentBuffer = @import("./bindings/MarkedArgumentBuffer.zig").MarkedArgumentBuffer;
+pub const RegularExpression = @import("./bindings/RegularExpression.zig").RegularExpression;
 
 // JavaScript-related
 pub const Errorable = @import("./bindings/Errorable.zig").Errorable;

src/bun.js/test/jest.zig

@@ -504,13 +504,13 @@ const ExpectTypeOf = expect.ExpectTypeOf;
 const bun = @import("bun");
 const ArrayIdentityContext = bun.ArrayIdentityContext;
 const Output = bun.Output;
-const RegularExpression = bun.RegularExpression;
 const default_allocator = bun.default_allocator;
 const logger = bun.logger;
 
 const jsc = bun.jsc;
 const CallFrame = jsc.CallFrame;
 const JSGlobalObject = jsc.JSGlobalObject;
 const JSValue = jsc.JSValue;
+const RegularExpression = jsc.RegularExpression;
 const VirtualMachine = jsc.VirtualMachine;
 const ZigString = jsc.ZigString;

src/bun.zig

@@ -1991,8 +1991,6 @@ pub const WTF = struct {
 
 pub const Wyhash11 = @import("./wyhash.zig").Wyhash11;
 
-pub const RegularExpression = @import("./bun.js/bindings/RegularExpression.zig").RegularExpression;
-
 const TODO_LOG = Output.scoped(.TODO, .visible);
 pub inline fn todo(src: std.builtin.SourceLocation, value: anytype) @TypeOf(value) {
     if (comptime Environment.allow_assert) {

src/bunfig.zig

@@ -731,6 +731,30 @@ pub const Bunfig = struct {
                             },
                         }
                     }
+
+                    if (install_obj.get("publicHoistPattern")) |public_hoist_pattern_expr| {
+                        install.public_hoist_pattern = bun.install.PnpmMatcher.fromExpr(
+                            allocator,
+                            public_hoist_pattern_expr,
+                            this.log,
+                            this.source,
+                        ) catch |err| switch (err) {
+                            error.OutOfMemory => |oom| return oom,
+                            error.UnexpectedExpr, error.InvalidRegExp => return error.@"Invalid Bunfig",
+                        };
+                    }
+
+                    if (install_obj.get("hoistPattern")) |hoist_pattern_expr| {
+                        install.hoist_pattern = bun.install.PnpmMatcher.fromExpr(
+                            allocator,
+                            hoist_pattern_expr,
+                            this.log,
+                            this.source,
+                        ) catch |err| switch (err) {
+                            error.OutOfMemory => |oom| return oom,
+                            error.UnexpectedExpr, error.InvalidRegExp => return error.@"Invalid Bunfig",
+                        };
+                    }
                 }
 
                 if (json.get("run")) |run_expr| {

src/cli.zig

@@ -1727,11 +1727,11 @@ const bun = @import("bun");
 const Environment = bun.Environment;
 const Global = bun.Global;
 const Output = bun.Output;
-const RegularExpression = bun.RegularExpression;
 const bun_js = bun.bun_js;
 const clap = bun.clap;
 const default_allocator = bun.default_allocator;
 const logger = bun.logger;
 const strings = bun.strings;
 const File = bun.sys.File;
+const RegularExpression = bun.jsc.RegularExpression;
 const api = bun.schema.api;

src/cli/Arguments.zig

@@ -1333,14 +1333,14 @@ const FeatureFlags = bun.FeatureFlags;
 const Global = bun.Global;
 const OOM = bun.OOM;
 const Output = bun.Output;
-const RegularExpression = bun.RegularExpression;
 const clap = bun.clap;
 const js_ast = bun.ast;
 const logger = bun.logger;
 const options = bun.options;
 const resolve_path = bun.path;
 const strings = bun.strings;
 const Api = bun.schema.api;
+const RegularExpression = bun.jsc.RegularExpression;
 
 const CLI = bun.cli;
 const Command = CLI.Command;

src/collections/array_list.zig

@@ -119,6 +119,10 @@ pub fn ArrayListAlignedIn(
             };
         }
 
+        pub fn writer(self: *Self) Unmanaged.Writer {
+            return self.#unmanaged.writer(self.getStdAllocator());
+        }
+
         /// Returns a borrowed version of the allocator.
         pub fn allocator(self: *const Self) bun.allocators.Borrowed(Allocator) {
             return bun.allocators.borrow(self.#allocator);

src/ini.zig

@@ -1073,6 +1073,36 @@ pub fn loadNpmrc(
         }
     }
 
+    if (out.get("public-hoist-pattern")) |public_hoist_pattern_expr| {
+        install.public_hoist_pattern = bun.install.PnpmMatcher.fromExpr(
+            allocator,
+            public_hoist_pattern_expr,
+            log,
+            source,
+        ) catch |err| switch (err) {
+            error.OutOfMemory => |oom| return oom,
+            error.InvalidRegExp, error.UnexpectedExpr => patterns: {
+                log.reset();
+                break :patterns null;
+            },
+        };
+    }
+
+    if (out.get("hoist-pattern")) |hoist_pattern_expr| {
+        install.hoist_pattern = bun.install.PnpmMatcher.fromExpr(
+            allocator,
+            hoist_pattern_expr,
+            log,
+            source,
+        ) catch |err| switch (err) {
+            error.OutOfMemory => |oom| return oom,
+            error.InvalidRegExp, error.UnexpectedExpr => patterns: {
+                log.reset();
+                break :patterns null;
+            },
+        };
+    }
+
     var registry_map = install.scoped orelse bun.schema.api.NpmRegistryMap{};
 
     // Process scopes

src/install/PackageManager/PackageManagerOptions.zig

@@ -71,6 +71,9 @@ depth: ?usize = null,
 /// isolated installs (pnpm-like) or hoisted installs (yarn-like, original)
 node_linker: NodeLinker = .auto,
 
+public_hoist_pattern: ?bun.install.PnpmMatcher = null,
+hoist_pattern: ?bun.install.PnpmMatcher = null,
+
 // Security scanner module path
 security_scanner: ?[]const u8 = null,
 
@@ -387,6 +390,14 @@ pub fn load(
             this.minimum_release_age_excludes = exclusions;
         }
 
+        if (config.public_hoist_pattern) |public_hoist_pattern| {
+            this.public_hoist_pattern = public_hoist_pattern;
+        }
+
+        if (config.hoist_pattern) |hoist_pattern| {
+            this.hoist_pattern = hoist_pattern;
+        }
+
         this.explicit_global_directory = config.global_dir orelse this.explicit_global_directory;
     }
 

src/install/PnpmMatcher.zig

@@ -0,0 +1,198 @@
+/// https://github.com/pnpm/pnpm/blob/3abd3946237aa6ba7831552310ec371ddd3616c2/config/matcher/src/index.ts
+const PnpmMatcher = @This();
+
+matchers: []const Matcher,
+behavior: Behavior,
+
+const Matcher = struct {
+    pattern: union(enum) {
+        match_all,
+        regex: *jsc.RegularExpression,
+    },
+    is_exclude: bool,
+};
+
+const Behavior = enum {
+    all_matchers_include,
+    all_matchers_exclude,
+    has_exclude_and_include_matchers,
+};
+
+const FromExprError = OOM || error{
+    InvalidRegExp,
+    UnexpectedExpr,
+};
+
+pub fn fromExpr(allocator: std.mem.Allocator, expr: ast.Expr, log: *logger.Log, source: *const logger.Source) FromExprError!PnpmMatcher {
+    var buf: collections.ArrayListDefault(u8) = .init();
+    defer buf.deinit();
+
+    bun.jsc.initialize(false);
+
+    var matchers: collections.ArrayListDefault(Matcher) = .init();
+
+    var has_include = false;
+    var has_exclude = false;
+
+    switch (expr.data) {
+        .e_string => {
+            const pattern = expr.data.e_string.slice(allocator);
+            const matcher = createMatcher(pattern, &buf) catch |err| switch (err) {
+                error.OutOfMemory => return err,
+                error.InvalidRegExp => {
+                    try log.addErrorFmtOpts(allocator, "Invalid regex: {s}", .{pattern}, .{
+                        .loc = expr.loc,
+                        .redact_sensitive_information = true,
+                        .source = source,
+                    });
+                    return err;
+                },
+            };
+            has_include = has_include or !matcher.is_exclude;
+            has_exclude = has_exclude or matcher.is_exclude;
+            try matchers.append(matcher);
+        },
+        .e_array => |patterns| {
+            for (patterns.slice()) |pattern_expr| {
+                if (try pattern_expr.asStringCloned(allocator)) |pattern| {
+                    const matcher = createMatcher(pattern, &buf) catch |err| switch (err) {
+                        error.OutOfMemory => return err,
+                        error.InvalidRegExp => {
+                            try log.addErrorFmtOpts(allocator, "Invalid regex: {s}", .{pattern}, .{
+                                .loc = pattern_expr.loc,
+                                .redact_sensitive_information = true,
+                                .source = source,
+                            });
+                            return err;
+                        },
+                    };
+                    has_include = has_include or !matcher.is_exclude;
+                    has_exclude = has_exclude or matcher.is_exclude;
+                    try matchers.append(matcher);
+                } else {
+                    try log.addErrorOpts("Expected a string", .{
+                        .loc = pattern_expr.loc,
+                        .redact_sensitive_information = true,
+                        .source = source,
+                    });
+                    return error.UnexpectedExpr;
+                }
+            }
+        },
+        else => {
+            try log.addErrorOpts("Expected a string or an array of strings", .{
+                .loc = expr.loc,
+                .redact_sensitive_information = true,
+                .source = source,
+            });
+            return error.UnexpectedExpr;
+        },
+    }
+
+    const behavior: Behavior = if (!has_include)
+        .all_matchers_exclude
+    else if (!has_exclude)
+        .all_matchers_include
+    else
+        .has_exclude_and_include_matchers;
+
+    return .{
+        .matchers = try matchers.toOwnedSlice(),
+        .behavior = behavior,
+    };
+}
+
+const CreateMatcherError = OOM || error{InvalidRegExp};
+
+fn createMatcher(raw: []const u8, buf: *collections.ArrayListDefault(u8)) CreateMatcherError!Matcher {
+    buf.clearRetainingCapacity();
+    var writer = buf.writer();
+
+    var trimmed = strings.trim(raw, &strings.whitespace_chars);
+
+    var is_exclude = false;
+    if (strings.startsWithChar(trimmed, '!')) {
+        is_exclude = true;
+        trimmed = trimmed[1..];
+    }
+
+    if (strings.eqlComptime(trimmed, "*")) {
+        return .{ .pattern = .match_all, .is_exclude = is_exclude };
+    }
+
+    try writer.writeByte('^');
+    try strings.escapeRegExpForPackageNameMatching(trimmed, writer);
+    try writer.writeByte('$');
+
+    const regex = try jsc.RegularExpression.init(.cloneUTF8(buf.items()), .none);
+
+    return .{ .pattern = .{ .regex = regex }, .is_exclude = is_exclude };
+}
+
+pub fn isMatch(this: *const PnpmMatcher, name: []const u8) bool {
+    if (this.matchers.len == 0) {
+        return false;
+    }
+
+    const name_str: String = .fromBytes(name);
+
+    switch (this.behavior) {
+        .all_matchers_include => {
+            for (this.matchers) |matcher| {
+                switch (matcher.pattern) {
+                    .match_all => {
+                        return true;
+                    },
+                    .regex => |regex| {
+                        if (regex.matches(name_str)) {
+                            return true;
+                        }
+                    },
+                }
+            }
+            return false;
+        },
+        .all_matchers_exclude => {
+            for (this.matchers) |matcher| {
+                switch (matcher.pattern) {
+                    .match_all => {
+                        return false;
+                    },
+                    .regex => |regex| {
+                        if (regex.matches(name_str)) {
+                            return false;
+                        }
+                    },
+                }
+            }
+            return true;
+        },
+        .has_exclude_and_include_matchers => {
+            var matches = false;
+            for (this.matchers) |matcher| {
+                switch (matcher.pattern) {
+                    .match_all => {
+                        matches = !matcher.is_exclude;
+                    },
+                    .regex => |regex| {
+                        if (regex.matches(name_str)) {
+                            matches = !matcher.is_exclude;
+                        }
+                    },
+                }
+            }
+            return matches;
+        },
+    }
+}
+
+const std = @import("std");
+
+const bun = @import("bun");
+const OOM = bun.OOM;
+const String = bun.String;
+const ast = bun.ast;
+const collections = bun.collections;
+const jsc = bun.jsc;
+const logger = bun.logger;
+const strings = bun.strings;