nurulhudaapon/temporalz
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: cabi > abi

Browse source
This commit is contained in:
Nurul Huda (Apon) 2026-01-26 13:04:58 +06:00
parent c85a7eed56
commit 13d1783b9f
3 changed files with 55 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/Duration.zig
View file

@ -1,6 +1,6 @@
const std = @import("std");
const temporal_rs = @import("cabi.zig");
const c = temporal_rs.c;
const abi = @import("abi.zig");
const c = abi.c;
const Duration = @This();
@ -36,13 +36,13 @@ pub fn init(
/// Parse an ISO 8601 duration string (Temporal.Duration.from).
pub fn from(text: []const u8) !Duration {
const view = temporal_rs.toDiplomatStringView(text);
const view = abi.toDiplomatStringView(text);
return wrapDuration(c.temporal_rs_Duration_from_utf8(view));
}
/// Parse an ISO 8601 UTF-16 duration string.
fn fromUtf16(text: []const u16) !Duration {
const view = temporal_rs.toDiplomatString16View(text);
const view = abi.toDiplomatString16View(text);
return wrapDuration(c.temporal_rs_Duration_from_utf16(view));
}
@ -151,30 +151,30 @@ fn roundWithProvider(self: Duration, options: RoundingOptions, relative_to: Rela
/// Compare two durations (Temporal.Duration.compare).
pub fn compare(self: Duration, other: Duration, relative_to: RelativeTo) !i8 {
const res = c.temporal_rs_Duration_compare(self._inner, other._inner, relative_to);
return temporal_rs.success(res) orelse return error.TemporalError;
return abi.success(res) orelse return error.TemporalError;
}
/// Compare two durations with an explicit provider.
fn compareWithProvider(self: Duration, other: Duration, relative_to: RelativeTo, provider: *const c.Provider) !i8 {
const res = c.temporal_rs_Duration_compare_with_provider(self._inner, other._inner, relative_to, provider);
return temporal_rs.success(res) orelse return error.TemporalError;
return abi.success(res) orelse return error.TemporalError;
}
/// Get the total value of the duration in the specified unit (Temporal.Duration.prototype.total).
pub fn total(self: Duration, unit: Unit, relative_to: RelativeTo) !f64 {
const res = c.temporal_rs_Duration_total(self._inner, @intFromEnum(unit), relative_to);
return temporal_rs.success(res) orelse return error.TemporalError;
return abi.success(res) orelse return error.TemporalError;
}
/// Get the total value of the duration with an explicit provider.
fn totalWithProvider(self: Duration, unit: Unit, relative_to: RelativeTo, provider: *const c.Provider) !f64 {
const res = c.temporal_rs_Duration_total_with_provider(self._inner, @intFromEnum(unit), relative_to, provider);
return temporal_rs.success(res) orelse return error.TemporalError;
return abi.success(res) orelse return error.TemporalError;
}
/// Convert to string (Temporal.Duration.prototype.toString); caller owns returned slice.
pub fn toString(self: Duration, allocator: std.mem.Allocator, options: ToStringRoundingOptions) ![]u8 {
var write = temporal_rs.DiplomatWrite.init(allocator);
var write = abi.DiplomatWrite.init(allocator);
defer write.deinit();
const res = c.temporal_rs_Duration_to_string(self._inner, options, &write.inner);
@ -206,16 +206,16 @@ pub fn deinit(self: Duration) void {
// --- Helpers -----------------------------------------------------------------
fn handleVoidResult(res: anytype) !void {
_ = temporal_rs.success(res) orelse return error.TemporalError;
_ = abi.success(res) orelse return error.TemporalError;
}
fn wrapDuration(res: anytype) !Duration {
const ptr = (temporal_rs.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
const ptr = (abi.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
return .{ ._inner = ptr };
}
fn defaultToStringRoundingOptions() ToStringRoundingOptions {
return temporal_rs.to_string_rounding_options_auto;
return abi.to_string_rounding_options_auto;
}
// --- Public helper types -----------------------------------------------------
@ -411,8 +411,8 @@ test toString {
}
test fromPartialDuration {
const empty_i64 = temporal_rs.toOption(c.OptionI64, null);
const empty_f64 = temporal_rs.toOption(c.OptionF64, null);
const empty_i64 = abi.toOption(c.OptionI64, null);
const empty_f64 = abi.toOption(c.OptionF64, null);
const partial = c.PartialDuration{
.years = empty_i64,

82
src/Instant.zig
View file

@ -1,6 +1,6 @@
const std = @import("std");
const temporal_rs = @import("cabi.zig");
const c = temporal_rs.c;
const abi = @import("abi.zig");
const c = abi.c;
const Instant = @This();
@ -68,19 +68,19 @@ pub fn fromEpochMilliseconds(epoch_ms: i64) !Instant {
/// Construct from epoch nanoseconds (Temporal.Instant.fromEpochNanoseconds).
pub fn fromEpochNanoseconds(epoch_ns: i128) !Instant {
const parts = temporal_rs.toI128Nanoseconds(epoch_ns);
const parts = abi.toI128Nanoseconds(epoch_ns);
return wrapInstant(c.temporal_rs_Instant_try_new(parts));
}
/// Parse an ISO 8601 string (Temporal.Instant.from).
pub fn from(text: []const u8) !Instant {
const view = temporal_rs.toDiplomatStringView(text);
const view = abi.toDiplomatStringView(text);
return wrapInstant(c.temporal_rs_Instant_from_utf8(view));
}
/// Parse an ISO 8601 UTF-16 string (Temporal.Instant.from).
fn fromUtf16(text: []const u16) !Instant {
const view = temporal_rs.toDiplomatString16View(text);
const view = abi.toDiplomatString16View(text);
return wrapInstant(c.temporal_rs_Instant_from_utf16(view));
}
@ -121,10 +121,10 @@ pub fn equals(a: Instant, b: Instant) bool {
/// Convert to string using compiled TZ data; caller owns returned slice.
pub fn toString(self: Instant, allocator: std.mem.Allocator, opts: ToStringOptions) ![]u8 {
const zone_opt = temporal_rs.toTimeZoneOption(opts.time_zone);
const zone_opt = abi.toTimeZoneOption(opts.time_zone);
const rounding = optsToRounding(opts);
var write = temporal_rs.DiplomatWrite.init(allocator);
var write = abi.DiplomatWrite.init(allocator);
defer write.deinit();
const res = c.temporal_rs_Instant_to_ixdtf_string_with_compiled_data(self._inner, zone_opt, rounding, &write.inner);
@ -135,10 +135,10 @@ pub fn toString(self: Instant, allocator: std.mem.Allocator, opts: ToStringOptio
/// Convert to string using an explicit provider.
fn toStringWithProvider(self: Instant, allocator: std.mem.Allocator, provider: *const Provider, opts: ToStringOptions) ![]u8 {
const zone_opt = temporal_rs.toTimeZoneOption(opts.time_zone);
const zone_opt = abi.toTimeZoneOption(opts.time_zone);
const rounding = optsToRounding(opts);
var write = temporal_rs.DiplomatWrite.init(allocator);
var write = abi.DiplomatWrite.init(allocator);
defer write.deinit();
const res = c.temporal_rs_Instant_to_ixdtf_string_with_provider(self._inner, zone_opt, rounding, provider, &write.inner);
@ -170,7 +170,7 @@ fn toZonedDateTimeIsoWithProvider(self: Instant, zone: TimeZone, provider: *cons
/// Clone the underlying instant.
fn clone(self: Instant) Instant {
const ptr = c.temporal_rs_Instant_clone(self._inner) orelse unreachable;
return .{ ._inner = ptr, .epoch_milliseconds = c.temporal_rs_Instant_epoch_milliseconds(ptr), .epoch_nanoseconds = temporal_rs.fromI128Nanoseconds(c.temporal_rs_Instant_epoch_nanoseconds(ptr)) };
return .{ ._inner = ptr, .epoch_milliseconds = c.temporal_rs_Instant_epoch_milliseconds(ptr), .epoch_nanoseconds = abi.fromI128Nanoseconds(c.temporal_rs_Instant_epoch_nanoseconds(ptr)) };
}
pub fn deinit(self: Instant) void {
@ -180,41 +180,41 @@ pub fn deinit(self: Instant) void {
// --- Helpers -----------------------------------------------------------------
fn wrapInstant(res: anytype) !Instant {
const ptr = (temporal_rs.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
const ptr = (abi.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
return .{
._inner = ptr,
.epoch_milliseconds = c.temporal_rs_Instant_epoch_milliseconds(ptr),
.epoch_nanoseconds = temporal_rs.fromI128Nanoseconds(c.temporal_rs_Instant_epoch_nanoseconds(ptr)),
.epoch_nanoseconds = abi.fromI128Nanoseconds(c.temporal_rs_Instant_epoch_nanoseconds(ptr)),
};
}
fn wrapDuration(res: anytype) !DurationHandle {
const ptr = (temporal_rs.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
const ptr = (abi.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
return .{ .ptr = ptr };
}
fn wrapZonedDateTime(res: anytype) !ZonedDateTimeHandle {
const ptr = (temporal_rs.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
const ptr = (abi.success(res) orelse return error.TemporalError) orelse return error.TemporalError;
return .{ .ptr = ptr };
}
fn handleVoidResult(res: anytype) !void {
_ = temporal_rs.success(res) orelse return error.TemporalError;
_ = abi.success(res) orelse return error.TemporalError;
}
fn defaultPrecision() Precision {
return .{ .is_minute = false, .precision = temporal_rs.toOption(c.OptionU8, null) };
return .{ .is_minute = false, .precision = abi.toOption(c.OptionU8, null) };
}
fn defaultToStringRoundingOptions() ToStringRoundingOptions {
return temporal_rs.to_string_rounding_options_auto;
return abi.to_string_rounding_options_auto;
}
/// Convert ToStringOptions to ToStringRoundingOptions for the C API
fn optsToRounding(opts: ToStringOptions) ToStringRoundingOptions {
// If smallest_unit is specified, use it; otherwise use fractional_second_digits for precision
const precision = if (opts.fractional_second_digits) |digits|
Precision{ .is_minute = false, .precision = temporal_rs.toOption(c.OptionU8, digits) }
Precision{ .is_minute = false, .precision = abi.toOption(c.OptionU8, digits) }
else
defaultPrecision();
@ -223,13 +223,13 @@ fn optsToRounding(opts: ToStringOptions) ToStringRoundingOptions {
return .{
.precision = precision,
.smallest_unit = temporal_rs.toUnitOption(smallest_unit),
.rounding_mode = temporal_rs.toRoundingModeOption(rounding_mode),
.smallest_unit = abi.toUnitOption(smallest_unit),
.rounding_mode = abi.toRoundingModeOption(rounding_mode),
};
}
fn parseDuration(text: []const u8) !DurationHandle {
const view = temporal_rs.toDiplomatStringView(text);
const view = abi.toDiplomatStringView(text);
return wrapDuration(c.temporal_rs_Duration_from_utf8(view));
}
@ -370,21 +370,21 @@ test until {
defer later.deinit();
const settings = DifferenceSettings{
.largest_unit = temporal_rs.toUnitOption(@intFromEnum(Unit.hour)),
.smallest_unit = temporal_rs.toUnitOption(@intFromEnum(Unit.second)),
.rounding_mode = temporal_rs.toRoundingModeOption(@intFromEnum(RoundingMode.trunc)),
.increment = temporal_rs.toOption(c.OptionU32, null),
.largest_unit = abi.toUnitOption(@intFromEnum(Unit.hour)),
.smallest_unit = abi.toUnitOption(@intFromEnum(Unit.second)),
.rounding_mode = abi.toRoundingModeOption(@intFromEnum(RoundingMode.trunc)),
.increment = abi.toOption(c.OptionU32, null),
};
var until_handle = try earlier.until(later, settings);
defer until_handle.deinit();
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(temporal_rs.c.temporal_rs_Duration_sign(until_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), temporal_rs.c.temporal_rs_Duration_hours(until_handle.ptr));
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(abi.c.temporal_rs_Duration_sign(until_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), abi.c.temporal_rs_Duration_hours(until_handle.ptr));
var since_handle = try later.since(earlier, settings);
defer since_handle.deinit();
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(temporal_rs.c.temporal_rs_Duration_sign(since_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), temporal_rs.c.temporal_rs_Duration_hours(since_handle.ptr));
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(abi.c.temporal_rs_Duration_sign(since_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), abi.c.temporal_rs_Duration_hours(since_handle.ptr));
}
test since {
@ -394,21 +394,21 @@ test since {
defer later.deinit();
const settings = DifferenceSettings{
.largest_unit = temporal_rs.toUnitOption(@intFromEnum(Unit.hour)),
.smallest_unit = temporal_rs.toUnitOption(@intFromEnum(Unit.second)),
.rounding_mode = temporal_rs.toRoundingModeOption(@intFromEnum(RoundingMode.trunc)),
.increment = temporal_rs.toOption(c.OptionU32, null),
.largest_unit = abi.toUnitOption(@intFromEnum(Unit.hour)),
.smallest_unit = abi.toUnitOption(@intFromEnum(Unit.second)),
.rounding_mode = abi.toRoundingModeOption(@intFromEnum(RoundingMode.trunc)),
.increment = abi.toOption(c.OptionU32, null),
};
var until_handle = try earlier.until(later, settings);
defer until_handle.deinit();
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(temporal_rs.c.temporal_rs_Duration_sign(until_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), temporal_rs.c.temporal_rs_Duration_hours(until_handle.ptr));
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(abi.c.temporal_rs_Duration_sign(until_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), abi.c.temporal_rs_Duration_hours(until_handle.ptr));
var since_handle = try later.since(earlier, settings);
defer since_handle.deinit();
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(temporal_rs.c.temporal_rs_Duration_sign(since_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), temporal_rs.c.temporal_rs_Duration_hours(since_handle.ptr));
try std.testing.expectEqual(Sign.positive, @as(Sign, @enumFromInt(abi.c.temporal_rs_Duration_sign(since_handle.ptr))));
try std.testing.expectEqual(@as(i64, 1), abi.c.temporal_rs_Duration_hours(since_handle.ptr));
}
test round {
@ -416,10 +416,10 @@ test round {
defer inst.deinit();
const opts = RoundingOptions{
.largest_unit = temporal_rs.toUnitOption(null),
.smallest_unit = temporal_rs.toUnitOption(@intFromEnum(Unit.second)),
.rounding_mode = temporal_rs.toRoundingModeOption(@intFromEnum(RoundingMode.half_expand)),
.increment = temporal_rs.toOption(c.OptionU32, null),
.largest_unit = abi.toUnitOption(null),
.smallest_unit = abi.toUnitOption(@intFromEnum(Unit.second)),
.rounding_mode = abi.toRoundingModeOption(@intFromEnum(RoundingMode.half_expand)),
.increment = abi.toOption(c.OptionU32, null),
};
const rounded = try inst.round(opts);

0
src/cabi.zig → src/abi.zig
View file