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

feat(instant): first version of Temporal.Instant with most apis

Browse source
This commit is contained in:
Nurul Huda (Apon) 2026-01-23 20:15:33 +06:00
parent cb36bb0e5d
commit e00a7477d6
6 changed files with 691 additions and 234 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
.gitignore vendored
View file

@ -1,2 +1,11 @@
zig-out
.zig-cache
# Ignore Rust build target directory
vendor/temporal/target
# But track the specific compiled libraries
!vendor/temporal/target/**/libtemporal.a
!vendor/temporal/target/**/temporal.lib
tmp

196
build.zig
View file

@ -1,156 +1,104 @@
const std = @import("std");
// Although this function looks imperative, it does not perform the build
// directly and instead it mutates the build graph (`b`) that will be then
// executed by an external runner. The functions in `std.Build` implement a DSL
// for defining build steps and express dependencies between them, allowing the
// build runner to parallelize the build automatically (and the cache system to
// know when a step doesn't need to be re-run).
pub fn build(b: *std.Build) void {
// Standard target options allow the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard optimization options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
// set a preferred release mode, allowing the user to decide how to optimize.
const optimize = b.standardOptimizeOption(.{});
// It's also possible to define more custom flags to toggle optional features
// of this build script using `b.option()`. All defined flags (including
// target and optimize options) will be listed when running `zig build --help`
// in this directory.
// This creates a module, which represents a collection of source files alongside
// some compilation options, such as optimization mode and linked system libraries.
// Zig modules are the preferred way of making Zig code available to consumers.
// addModule defines a module that we intend to make available for importing
// to our consumers. We must give it a name because a Zig package can expose
// multiple modules and consumers will need to be able to specify which
// module they want to access.
const mod = b.addModule("temporalz", .{
// The root source file is the "entry point" of this module. Users of
// this module will only be able to access public declarations contained
// in this file, which means that if you have declarations that you
// intend to expose to consumers that were defined in other files part
// of this module, you will have to make sure to re-export them from
// the root file.
.root_source_file = b.path("src/root.zig"),
// Later on we'll use this module as the root module of a test executable
// which requires us to specify a target.
.target = target,
});
mod.addObjectFile(b.path(getTemporalRsPath(target)));
// Here we define an executable. An executable needs to have a root module
// which needs to expose a `main` function. While we could add a main function
// to the module defined above, it's sometimes preferable to split business
// logic and the CLI into two separate modules.
//
// If your goal is to create a Zig library for others to use, consider if
// it might benefit from also exposing a CLI tool. A parser library for a
// data serialization format could also bundle a CLI syntax checker, for example.
//
// If instead your goal is to create an executable, consider if users might
// be interested in also being able to embed the core functionality of your
// program in their own executable in order to avoid the overhead involved in
// subprocessing your CLI tool.
//
// If neither case applies to you, feel free to delete the declaration you
// don't need and to put everything under a single module.
const exe = b.addExecutable(.{
.name = "temporalz",
.root_module = b.createModule(.{
// b.createModule defines a new module just like b.addModule but,
// unlike b.addModule, it does not expose the module to consumers of
// this package, which is why in this case we don't have to give it a name.
.root_source_file = b.path("src/main.zig"),
// Target and optimization levels must be explicitly wired in when
// defining an executable or library (in the root module), and you
// can also hardcode a specific target for an executable or library
// definition if desireable (e.g. firmware for embedded devices).
.target = target,
.optimize = optimize,
// List of modules available for import in source files part of the
// root module.
.imports = &.{
// Here "temporalz" is the name you will use in your source code to
// import this module (e.g. `@import("temporalz")`). The name is
// repeated because you are allowed to rename your imports, which
// can be extremely useful in case of collisions (which can happen
// importing modules from different packages).
.{ .name = "temporalz", .module = mod },
},
}),
});
// This declares intent for the executable to be installed into the
// install prefix when running `zig build` (i.e. when executing the default
// step). By default the install prefix is `zig-out/` but can be overridden
// by passing `--prefix` or `-p`.
b.installArtifact(exe);
// This creates a top level step. Top level steps have a name and can be
// invoked by name when running `zig build` (e.g. `zig build run`).
// This will evaluate the `run` step rather than the default step.
// For a top level step to actually do something, it must depend on other
// steps (e.g. a Run step, as we will see in a moment).
const run_step = b.step("run", "Run the app");
// This creates a RunArtifact step in the build graph. A RunArtifact step
// invokes an executable compiled by Zig. Steps will only be executed by the
// runner if invoked directly by the user (in the case of top level steps)
// or if another step depends on it, so it's up to you to define when and
// how this Run step will be executed. In our case we want to run it when
// the user runs `zig build run`, so we create a dependency link.
// Run command
const run_cmd = b.addRunArtifact(exe);
run_step.dependOn(&run_cmd.step);
// By making the run step depend on the default step, it will be run from the
// installation directory rather than directly from within the cache directory.
run_cmd.step.dependOn(b.getInstallStep());
// This allows the user to pass arguments to the application in the build
// command itself, like this: `zig build run -- arg1 arg2 etc`
if (b.args) |args| {
run_cmd.addArgs(args);
}
const run_step = b.step("run", "Run the app");
// Creates an executable that will run `test` blocks from the provided module.
// Here `mod` needs to define a target, which is why earlier we made sure to
// set the releative field.
const mod_tests = b.addTest(.{
.root_module = mod,
});
// A run step that will run the test executable.
const run_mod_tests = b.addRunArtifact(mod_tests);
// Creates an executable that will run `test` blocks from the executable's
// root module. Note that test executables only test one module at a time,
// hence why we have to create two separate ones.
const exe_tests = b.addTest(.{
.root_module = exe.root_module,
});
// A run step that will run the second test executable.
const run_exe_tests = b.addRunArtifact(exe_tests);
// A top level step for running all tests. dependOn can be called multiple
// times and since the two run steps do not depend on one another, this will
// make the two of them run in parallel.
// Tests
{
run_step.dependOn(&run_cmd.step);
const test_step = b.step("test", "Run tests");
test_step.dependOn(&run_mod_tests.step);
test_step.dependOn(&run_exe_tests.step);
// Just like flags, top level steps are also listed in the `--help` menu.
//
// The Zig build system is entirely implemented in userland, which means
// that it cannot hook into private compiler APIs. All compilation work
// orchestrated by the build system will result in other Zig compiler
// subcommands being invoked with the right flags defined. You can observe
// these invocations when one fails (or you pass a flag to increase
// verbosity) to validate assumptions and diagnose problems.
//
// Lastly, the Zig build system is relatively simple and self-contained,
// and reading its source code will allow you to master it.
const mod_tests = b.addTest(.{ .root_module = mod });
test_step.dependOn(&b.addRunArtifact(mod_tests).step);
const exe_tests = b.addTest(.{ .root_module = exe.root_module });
test_step.dependOn(&b.addRunArtifact(exe_tests).step);
}
// Rust cross-compilation prebuild
{
const rust_prebuild_step = b.step("temporal-rs", "Build and vendor Rust staticlibs for supported targets");
var rustup_args: [3 + rust_targets.len][]const u8 = undefined;
rustup_args[0] = "rustup";
rustup_args[1] = "target";
rustup_args[2] = "add";
for (rust_targets, 0..) |t, i| {
rustup_args[3 + i] = t.triple;
}
const rustup_add = b.addSystemCommand(&rustup_args);
rust_prebuild_step.dependOn(&rustup_add.step);
for (rust_targets) |t| {
const cargo_build = b.addSystemCommand(&.{
"cargo",
"build",
"--release",
"--manifest-path",
"vendor/temporal/Cargo.toml",
"--target",
t.triple,
});
cargo_build.step.dependOn(&rustup_add.step);
rust_prebuild_step.dependOn(&cargo_build.step);
}
}
}
// Supported cross-compilation targets
const rust_targets = [_]struct { triple: []const u8 }{
.{ .triple = "aarch64-apple-darwin" },
.{ .triple = "x86_64-apple-darwin" },
.{ .triple = "x86_64-unknown-linux-gnu" },
.{ .triple = "aarch64-unknown-linux-gnu" },
.{ .triple = "x86_64-pc-windows-msvc" },
.{ .triple = "aarch64-pc-windows-msvc" },
};
// Platform-specific Rust library path resolution
fn getTemporalRsPath(target: std.Build.ResolvedTarget) []const u8 {
const arch_tag = target.result.cpu.arch;
return switch (target.result.os.tag) {
.macos => switch (arch_tag) {
.aarch64 => "vendor/temporal/target/aarch64-apple-darwin/release/libtemporal.a",
.x86_64 => "vendor/temporal/target/x86_64-apple-darwin/release/libtemporal.a",
else => @panic("unsupported macOS architecture"),
},
.linux => switch (arch_tag) {
.x86_64 => "vendor/temporal/target/x86_64-unknown-linux-gnu/release/libtemporal.a",
.aarch64 => "vendor/temporal/target/aarch64-unknown-linux-gnu/release/libtemporal.a",
else => @panic("unsupported Linux architecture"),
},
.windows => switch (arch_tag) {
.x86_64 => "vendor/temporal/target/x86_64-pc-windows-msvc/release/libtemporal.lib",
.aarch64 => "vendor/temporal/target/aarch64-pc-windows-msvc/release/libtemporal.lib",
else => @panic("unsupported Windows architecture"),
},
else => @panic("unsupported OS"),
};
}

74
build.zig.zon
View file

@ -1,81 +1,13 @@
.{
// This is the default name used by packages depending on this one. For
// example, when a user runs `zig fetch --save <url>`, this field is used
// as the key in the `dependencies` table. Although the user can choose a
// different name, most users will stick with this provided value.
//
// It is redundant to include "zig" in this name because it is already
// within the Zig package namespace.
.name = .temporalz,
// This is a [Semantic Version](https://semver.org/).
// In a future version of Zig it will be used for package deduplication.
.version = "0.0.0",
// Together with name, this represents a globally unique package
// identifier. This field is generated by the Zig toolchain when the
// package is first created, and then *never changes*. This allows
// unambiguous detection of one package being an updated version of
// another.
//
// When forking a Zig project, this id should be regenerated (delete the
// field and run `zig build`) if the upstream project is still maintained.
// Otherwise, the fork is *hostile*, attempting to take control over the
// original project's identity. Thus it is recommended to leave the comment
// on the following line intact, so that it shows up in code reviews that
// modify the field.
.fingerprint = 0xd8d79d59acc4faae, // Changing this has security and trust implications.
// Tracks the earliest Zig version that the package considers to be a
// supported use case.
.fingerprint = 0xd8d79d59acc4faae,
.minimum_zig_version = "0.15.2",
// This field is optional.
// Each dependency must either provide a `url` and `hash`, or a `path`.
// `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
// Once all dependencies are fetched, `zig build` no longer requires
// internet connectivity.
.dependencies = .{
// See `zig fetch --save <url>` for a command-line interface for adding dependencies.
//.example = .{
// // When updating this field to a new URL, be sure to delete the corresponding
// // `hash`, otherwise you are communicating that you expect to find the old hash at
// // the new URL. If the contents of a URL change this will result in a hash mismatch
// // which will prevent zig from using it.
// .url = "https://example.com/foo.tar.gz",
//
// // This is computed from the file contents of the directory of files that is
// // obtained after fetching `url` and applying the inclusion rules given by
// // `paths`.
// //
// // This field is the source of truth; packages do not come from a `url`; they
// // come from a `hash`. `url` is just one of many possible mirrors for how to
// // obtain a package matching this `hash`.
// //
// // Uses the [multihash](https://multiformats.io/multihash/) format.
// .hash = "...",
//
// // When this is provided, the package is found in a directory relative to the
// // build root. In this case the package's hash is irrelevant and therefore not
// // computed. This field and `url` are mutually exclusive.
// .path = "foo",
//
// // When this is set to `true`, a package is declared to be lazily
// // fetched. This makes the dependency only get fetched if it is
// // actually used.
// .lazy = false,
//},
},
// Specifies the set of files and directories that are included in this package.
// Only files and directories listed here are included in the `hash` that
// is computed for this package. Only files listed here will remain on disk
// when using the zig package manager. As a rule of thumb, one should list
// files required for compilation plus any license(s).
// Paths are relative to the build root. Use the empty string (`""`) to refer to
// the build root itself.
// A directory listed here means that all files within, recursively, are included.
.dependencies = .{},
.paths = .{
"build.zig",
"build.zig.zon",
"src",
// For example...
//"LICENSE",
//"README.md",
"vendor",
},
}

572
src/Instant.zig Normal file
View file

@ -0,0 +1,572 @@
const std = @import("std");
pub const Instant = @This();
inner: *CInstant,
epoch: i64,
/// Construct from epoch milliseconds (Temporal.Instant.fromEpochMilliseconds).
pub fn init(epoch_ms: i64) !Instant {
return fromEpochMilliseconds(epoch_ms);
}
/// Construct from epoch milliseconds.
pub fn fromEpochMilliseconds(epoch_ms: i64) !Instant {
return wrapInstant(temporal_rs_Instant_from_epoch_milliseconds(epoch_ms));
}
/// Construct from epoch nanoseconds (Temporal.Instant.fromEpochNanoseconds).
pub fn fromEpochNanoseconds(epoch_ns: i128) !Instant {
const parts = i128ToParts(epoch_ns);
return wrapInstant(temporal_rs_Instant_try_new(parts));
}
/// Parse an ISO 8601 string (Temporal.Instant.from).
pub fn fromUtf8(text: []const u8) !Instant {
const view = DiplomatStringView{ .data = text.ptr, .len = text.len };
return wrapInstant(temporal_rs_Instant_from_utf8(view));
}
/// Parse an ISO 8601 UTF-16 string (Temporal.Instant.from).
pub fn fromUtf16(text: []const u16) !Instant {
const view = DiplomatString16View{ .data = text.ptr, .len = text.len };
return wrapInstant(temporal_rs_Instant_from_utf16(view));
}
/// Add a Duration to this instant (Temporal.Instant.prototype.add).
pub fn add(self: Instant, duration: *const Duration) !Instant {
return wrapInstant(temporal_rs_Instant_add(self.inner, duration));
}
/// Subtract a Duration from this instant (Temporal.Instant.prototype.subtract).
pub fn subtract(self: Instant, duration: *const Duration) !Instant {
return wrapInstant(temporal_rs_Instant_subtract(self.inner, duration));
}
/// Difference until another instant (Temporal.Instant.prototype.until).
pub fn until(self: Instant, other: Instant, settings: DifferenceSettings) !DurationHandle {
return wrapDuration(temporal_rs_Instant_until(self.inner, other.inner, settings));
}
/// Difference since another instant (Temporal.Instant.prototype.since).
pub fn since(self: Instant, other: Instant, settings: DifferenceSettings) !DurationHandle {
return wrapDuration(temporal_rs_Instant_since(self.inner, other.inner, settings));
}
/// Round this instant (Temporal.Instant.prototype.round).
pub fn round(self: Instant, options: RoundingOptions) !Instant {
return wrapInstant(temporal_rs_Instant_round(self.inner, options));
}
/// Compare two instants (Temporal.Instant.compare).
pub fn compare(a: Instant, b: Instant) i8 {
return temporal_rs_Instant_compare(a.inner, b.inner);
}
/// Equality check (Temporal.Instant.prototype.equals).
pub fn equals(a: Instant, b: Instant) bool {
return temporal_rs_Instant_equals(a.inner, b.inner);
}
/// Epoch milliseconds accessor (Temporal.Instant.prototype.epochMilliseconds).
pub fn epochMilliseconds(self: Instant) i64 {
return temporal_rs_Instant_epoch_milliseconds(self.inner);
}
/// Epoch nanoseconds accessor (Temporal.Instant.prototype.epochNanoseconds).
pub fn epochNanoseconds(self: Instant) i128 {
const value = temporal_rs_Instant_epoch_nanoseconds(self.inner);
return partsToI128(value);
}
/// 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 = if (opts.time_zone) |z|
TimeZone_option{ .ok = z, .is_ok = true }
else
TimeZone_option{ .ok = undefined, .is_ok = false };
const rounding = opts.rounding orelse defaultToStringRoundingOptions();
const writer = diplomat_buffer_write_create(128);
defer diplomat_buffer_write_destroy(writer);
const res = temporal_rs_Instant_to_ixdtf_string_with_compiled_data(self.inner, zone_opt, rounding, writer);
try handleVoidResult(res);
const len = diplomat_buffer_write_len(writer);
const source = diplomat_buffer_write_get_bytes(writer)[0..len];
const out = try allocator.alloc(u8, len);
std.mem.copyForwards(u8, out, source);
return out;
}
/// Convert to string using an explicit provider.
pub fn toStringWithProvider(self: Instant, allocator: std.mem.Allocator, provider: *const Provider, opts: ToStringOptions) ![]u8 {
const zone_opt = if (opts.time_zone) |z|
TimeZone_option{ .ok = z, .is_ok = true }
else
TimeZone_option{ .ok = undefined, .is_ok = false };
const rounding = opts.rounding orelse defaultToStringRoundingOptions();
const writer = diplomat_buffer_write_create(128);
defer diplomat_buffer_write_destroy(writer);
const res = temporal_rs_Instant_to_ixdtf_string_with_provider(self.inner, zone_opt, rounding, provider, writer);
try handleVoidResult(res);
const len = diplomat_buffer_write_len(writer);
const source = diplomat_buffer_write_get_bytes(writer)[0..len];
const out = try allocator.alloc(u8, len);
std.mem.copyForwards(u8, out, source);
return out;
}
/// Convert to ZonedDateTime using built-in provider (Temporal.Instant.prototype.toZonedDateTimeISO).
pub fn toZonedDateTimeIso(self: Instant, zone: TimeZone) !ZonedDateTimeHandle {
return wrapZonedDateTime(temporal_rs_Instant_to_zoned_date_time_iso(self.inner, zone));
}
/// Convert to ZonedDateTime using an explicit provider.
pub fn toZonedDateTimeIsoWithProvider(self: Instant, zone: TimeZone, provider: *const Provider) !ZonedDateTimeHandle {
return wrapZonedDateTime(temporal_rs_Instant_to_zoned_date_time_iso_with_provider(self.inner, zone, provider));
}
/// Clone the underlying instant.
pub fn clone(self: Instant) Instant {
const ptr = temporal_rs_Instant_clone(self.inner);
return .{ .inner = ptr, .epoch = temporal_rs_Instant_epoch_milliseconds(ptr) };
}
pub fn deinit(self: Instant) void {
temporal_rs_Instant_destroy(self.inner);
}
// --- Helpers -----------------------------------------------------------------
fn wrapInstant(res: InstantResult) !Instant {
if (!res.is_ok) return error.TemporalError;
const ptr = res.result.ok orelse return error.TemporalError;
return .{ .inner = ptr, .epoch = temporal_rs_Instant_epoch_milliseconds(ptr) };
}
fn wrapDuration(res: DurationResult) !DurationHandle {
if (!res.is_ok) return error.TemporalError;
const ptr = res.result.ok orelse return error.TemporalError;
return .{ .ptr = ptr };
}
fn wrapZonedDateTime(res: ZonedDateTimeResult) !ZonedDateTimeHandle {
if (!res.is_ok) return error.TemporalError;
const ptr = res.result.ok orelse return error.TemporalError;
return .{ .ptr = ptr };
}
fn handleVoidResult(res: VoidResult) !void {
if (!res.is_ok) return error.TemporalError;
}
fn i128ToParts(value: i128) I128Nanoseconds {
const is_neg = value < 0;
const mag: u128 = if (is_neg) @intCast(@as(u128, @intCast(-value))) else @intCast(value);
const mask: u64 = 1 << 63;
var high: u64 = @intCast(mag >> 64);
const low: u64 = @intCast(mag & 0xffff_ffff_ffff_ffff);
if (is_neg) high |= mask;
return .{ .high = high, .low = low };
}
fn partsToI128(value: I128Nanoseconds) i128 {
const mask: u64 = 1 << 63;
const is_neg = (value.high & mask) != 0;
const mag: u128 = ((@as(u128, value.high & ~mask)) << 64) | value.low;
if (is_neg) return -@as(i128, @intCast(mag));
return @as(i128, @intCast(mag));
}
fn defaultPrecision() Precision {
return .{ .is_minute = false, .precision = OptionU8{ .ok = 0, .is_ok = false } };
}
fn defaultToStringRoundingOptions() ToStringRoundingOptions {
return .{
.precision = defaultPrecision(),
.smallest_unit = Unit_option{ .ok = .Unit_Auto, .is_ok = false },
.rounding_mode = RoundingMode_option{ .ok = .RoundingMode_Trunc, .is_ok = false },
};
}
fn parseDuration(text: []const u8) !DurationHandle {
const view = DiplomatStringView{ .data = text.ptr, .len = text.len };
const res = temporal_rs_Duration_from_utf8(view);
if (!res.is_ok) return error.TemporalError;
const ptr = res.result.ok orelse return error.TemporalError;
return .{ .ptr = ptr };
}
// --- Public helper types -----------------------------------------------------
pub const ToStringOptions = struct {
time_zone: ?TimeZone = null,
rounding: ?ToStringRoundingOptions = null,
};
pub const DurationHandle = struct {
ptr: *Duration,
pub fn deinit(self: DurationHandle) void {
temporal_rs_Duration_destroy(self.ptr);
}
};
pub const ZonedDateTimeHandle = struct {
ptr: *ZonedDateTime,
pub fn deinit(self: ZonedDateTimeHandle) void {
temporal_rs_ZonedDateTime_destroy(self.ptr);
}
};
// --- Extern types ------------------------------------------------------------
const CInstant = opaque {};
pub const Duration = opaque {};
pub const ZonedDateTime = opaque {};
pub const Provider = opaque {};
pub const I128Nanoseconds = extern struct { high: u64, low: u64 };
pub const I128Nanoseconds_option = extern struct { ok: I128Nanoseconds, is_ok: bool };
pub const DiplomatStringView = extern struct { data: [*c]const u8, len: usize };
pub const DiplomatString16View = extern struct { data: [*c]const u16, len: usize };
pub const OptionStringView = extern struct { ok: DiplomatStringView, is_ok: bool };
pub const OptionU8 = extern struct { ok: u8, is_ok: bool };
pub const OptionU32 = extern struct { ok: u32, is_ok: bool };
pub const DiplomatWrite = extern struct {
context: ?*anyopaque,
buf: [*c]u8,
len: usize,
cap: usize,
grow_failed: bool,
flush: ?*const fn (*DiplomatWrite) void,
grow: ?*const fn (*DiplomatWrite, usize) bool,
};
pub const TimeZone = extern struct {
offset_minutes: i16,
resolved_id: usize,
normalized_id: usize,
is_iana_id: bool,
};
pub const TimeZone_option = extern struct {
ok: TimeZone,
is_ok: bool,
};
pub const Precision = extern struct {
is_minute: bool,
precision: OptionU8,
};
pub const Unit = enum(c_int) {
Unit_Auto = 0,
Unit_Nanosecond = 1,
Unit_Microsecond = 2,
Unit_Millisecond = 3,
Unit_Second = 4,
Unit_Minute = 5,
Unit_Hour = 6,
Unit_Day = 7,
Unit_Week = 8,
Unit_Month = 9,
Unit_Year = 10,
};
pub const Unit_option = extern struct { ok: Unit, is_ok: bool };
pub const RoundingMode = enum(c_int) {
RoundingMode_Ceil = 0,
RoundingMode_Floor = 1,
RoundingMode_Expand = 2,
RoundingMode_Trunc = 3,
RoundingMode_HalfCeil = 4,
RoundingMode_HalfFloor = 5,
RoundingMode_HalfExpand = 6,
RoundingMode_HalfTrunc = 7,
RoundingMode_HalfEven = 8,
};
pub const RoundingMode_option = extern struct { ok: RoundingMode, is_ok: bool };
pub const DifferenceSettings = extern struct {
largest_unit: Unit_option,
smallest_unit: Unit_option,
rounding_mode: RoundingMode_option,
increment: OptionU32,
};
pub const RoundingOptions = extern struct {
largest_unit: Unit_option,
smallest_unit: Unit_option,
rounding_mode: RoundingMode_option,
increment: OptionU32,
};
pub const ToStringRoundingOptions = extern struct {
precision: Precision,
smallest_unit: Unit_option,
rounding_mode: RoundingMode_option,
};
pub const ErrorKind = enum(c_int) {
ErrorKind_Generic = 0,
ErrorKind_Type = 1,
ErrorKind_Range = 2,
ErrorKind_Syntax = 3,
ErrorKind_Assert = 4,
};
pub const TemporalError = extern struct {
kind: ErrorKind,
msg: OptionStringView,
};
pub const Sign = enum(c_int) {
Sign_Positive = 1,
Sign_Zero = 0,
Sign_Negative = -1,
};
// --- Result wrappers ---------------------------------------------------------
const InstantResult = extern struct {
result: extern union {
ok: ?*CInstant,
err: TemporalError,
},
is_ok: bool,
};
const DurationResult = extern struct {
result: extern union {
ok: ?*Duration,
err: TemporalError,
},
is_ok: bool,
};
const DurationParseResult = extern struct {
result: extern union {
ok: ?*Duration,
err: TemporalError,
},
is_ok: bool,
};
const ZonedDateTimeResult = extern struct {
result: extern union {
ok: ?*ZonedDateTime,
err: TemporalError,
},
is_ok: bool,
};
const VoidResult = extern struct {
result: extern union {
err: TemporalError,
},
is_ok: bool,
};
// --- Extern functions -------------------------------------------------------
extern "c" fn temporal_rs_Instant_try_new(ns: I128Nanoseconds) InstantResult;
extern "c" fn temporal_rs_Instant_from_epoch_milliseconds(epoch_milliseconds: i64) InstantResult;
extern "c" fn temporal_rs_Instant_from_utf8(s: DiplomatStringView) InstantResult;
extern "c" fn temporal_rs_Instant_from_utf16(s: DiplomatString16View) InstantResult;
extern "c" fn temporal_rs_Instant_add(self: *const CInstant, duration: *const Duration) InstantResult;
extern "c" fn temporal_rs_Instant_subtract(self: *const CInstant, duration: *const Duration) InstantResult;
extern "c" fn temporal_rs_Instant_since(self: *const CInstant, other: *const CInstant, settings: DifferenceSettings) DurationResult;
extern "c" fn temporal_rs_Instant_until(self: *const CInstant, other: *const CInstant, settings: DifferenceSettings) DurationResult;
extern "c" fn temporal_rs_Instant_round(self: *const CInstant, options: RoundingOptions) InstantResult;
extern "c" fn temporal_rs_Instant_compare(self: *const CInstant, other: *const CInstant) i8;
extern "c" fn temporal_rs_Instant_equals(self: *const CInstant, other: *const CInstant) bool;
extern "c" fn temporal_rs_Instant_epoch_milliseconds(self: *const CInstant) i64;
extern "c" fn temporal_rs_Instant_epoch_nanoseconds(self: *const CInstant) I128Nanoseconds;
extern "c" fn temporal_rs_Instant_to_ixdtf_string_with_compiled_data(self: *const CInstant, zone: TimeZone_option, options: ToStringRoundingOptions, write: *DiplomatWrite) VoidResult;
extern "c" fn temporal_rs_Instant_to_ixdtf_string_with_provider(self: *const CInstant, zone: TimeZone_option, options: ToStringRoundingOptions, p: *const Provider, write: *DiplomatWrite) VoidResult;
extern "c" fn temporal_rs_Instant_to_zoned_date_time_iso(self: *const CInstant, zone: TimeZone) ZonedDateTimeResult;
extern "c" fn temporal_rs_Instant_to_zoned_date_time_iso_with_provider(self: *const CInstant, zone: TimeZone, p: *const Provider) ZonedDateTimeResult;
extern "c" fn temporal_rs_Instant_clone(self: *const CInstant) *CInstant;
extern "c" fn temporal_rs_Instant_destroy(self: *CInstant) void;
extern "c" fn temporal_rs_Duration_destroy(self: *Duration) void;
extern "c" fn temporal_rs_Duration_from_utf8(s: DiplomatStringView) DurationParseResult;
extern "c" fn temporal_rs_Duration_hours(self: *const Duration) i64;
extern "c" fn temporal_rs_Duration_minutes(self: *const Duration) i64;
extern "c" fn temporal_rs_Duration_seconds(self: *const Duration) i64;
extern "c" fn temporal_rs_Duration_milliseconds(self: *const Duration) i64;
extern "c" fn temporal_rs_Duration_microseconds(self: *const Duration) f64;
extern "c" fn temporal_rs_Duration_nanoseconds(self: *const Duration) f64;
extern "c" fn temporal_rs_Duration_sign(self: *const Duration) Sign;
extern "c" fn temporal_rs_ZonedDateTime_destroy(self: *ZonedDateTime) void;
extern "c" fn diplomat_buffer_write_create(cap: usize) *DiplomatWrite;
extern "c" fn diplomat_buffer_write_get_bytes(write: *DiplomatWrite) [*c]u8;
extern "c" fn diplomat_buffer_write_len(write: *DiplomatWrite) usize;
extern "c" fn diplomat_buffer_write_destroy(write: *DiplomatWrite) void;
// --- Tests -------------------------------------------------------------------
test "instant epoch milliseconds roundtrip" {
const epoch_ms: i64 = 1_704_067_200_000; // 2024-01-01T00:00:00Z
const inst = try Instant.init(epoch_ms);
defer inst.deinit();
try std.testing.expectEqual(epoch_ms, inst.epochMilliseconds());
}
test "instant epoch nanoseconds bounds" {
// The Rust implementation accepts values within the 100M-day window (inclusive).
const max_ns: i128 = 8_640_000_000_000_000_000_000;
const min_ns: i128 = -max_ns;
const max_inst = try Instant.fromEpochNanoseconds(max_ns);
defer max_inst.deinit();
const min_inst = try Instant.fromEpochNanoseconds(min_ns);
defer min_inst.deinit();
try std.testing.expectEqual(max_ns, max_inst.epochNanoseconds());
try std.testing.expectEqual(min_ns, min_inst.epochNanoseconds());
try std.testing.expectError(error.TemporalError, Instant.fromEpochNanoseconds(max_ns + 1));
try std.testing.expectError(error.TemporalError, Instant.fromEpochNanoseconds(min_ns - 1));
}
test "instant parse utf8" {
const inst = try Instant.fromUtf8("2024-03-15T14:30:45.123Z");
defer inst.deinit();
try std.testing.expectEqual(@as(i64, 1_710_513_045_123), inst.epochMilliseconds());
}
test "instant parse utf16" {
const utf8 = "2024-03-15T14:30:45.123Z";
const allocator = std.testing.allocator;
const utf16 = try std.unicode.utf8ToUtf16LeAlloc(allocator, utf8);
defer allocator.free(utf16);
const inst = try Instant.fromUtf16(utf16);
defer inst.deinit();
try std.testing.expectEqual(@as(i64, 1_710_513_045_123), inst.epochMilliseconds());
}
test "instant add subtract duration" {
const base = try Instant.fromEpochMilliseconds(0);
defer base.deinit();
var dur = try parseDuration("PT1H30M");
defer dur.deinit();
const added = try base.add(dur.ptr);
defer added.deinit();
try std.testing.expectEqual(@as(i64, 5_400_000), added.epochMilliseconds());
const subbed = try added.subtract(dur.ptr);
defer subbed.deinit();
try std.testing.expectEqual(@as(i64, 0), subbed.epochMilliseconds());
}
test "instant compare and equals" {
const a = try Instant.fromEpochMilliseconds(0);
defer a.deinit();
const b = try Instant.fromEpochMilliseconds(0);
defer b.deinit();
const c = try Instant.fromEpochMilliseconds(1_000);
defer c.deinit();
try std.testing.expectEqual(@as(i8, 0), Instant.compare(a, b));
try std.testing.expect(Instant.equals(a, b));
try std.testing.expectEqual(@as(i8, -1), Instant.compare(a, c));
try std.testing.expectEqual(@as(i8, 1), Instant.compare(c, a));
}
test "instant until and since basic" {
const earlier = try Instant.fromEpochMilliseconds(0);
defer earlier.deinit();
const later = try Instant.fromEpochMilliseconds(3_600_000);
defer later.deinit();
const settings = DifferenceSettings{
.largest_unit = Unit_option{ .ok = .Unit_Hour, .is_ok = true },
.smallest_unit = Unit_option{ .ok = .Unit_Second, .is_ok = true },
.rounding_mode = RoundingMode_option{ .ok = .RoundingMode_Trunc, .is_ok = true },
.increment = OptionU32{ .ok = 0, .is_ok = false },
};
var until_handle = try earlier.until(later, settings);
defer until_handle.deinit();
try std.testing.expectEqual(Sign.Sign_Positive, temporal_rs_Duration_sign(until_handle.ptr));
try std.testing.expectEqual(@as(i64, 1), temporal_rs_Duration_hours(until_handle.ptr));
var since_handle = try later.since(earlier, settings);
defer since_handle.deinit();
try std.testing.expectEqual(Sign.Sign_Positive, temporal_rs_Duration_sign(since_handle.ptr));
try std.testing.expectEqual(@as(i64, 1), temporal_rs_Duration_hours(since_handle.ptr));
}
test "instant round to second" {
const inst = try Instant.fromEpochNanoseconds(1_609_459_245_123_456_789);
defer inst.deinit();
const opts = RoundingOptions{
.largest_unit = Unit_option{ .ok = .Unit_Auto, .is_ok = false },
.smallest_unit = Unit_option{ .ok = .Unit_Second, .is_ok = true },
.rounding_mode = RoundingMode_option{ .ok = .RoundingMode_HalfExpand, .is_ok = true },
.increment = OptionU32{ .ok = 0, .is_ok = false },
};
const rounded = try inst.round(opts);
defer rounded.deinit();
const ns = rounded.epochNanoseconds();
try std.testing.expectEqual(@as(i128, 1_609_459_245_000_000_000), ns);
}
test "instant clone preserves epoch" {
const inst = try Instant.fromEpochMilliseconds(42);
defer inst.deinit();
const cloned = inst.clone();
defer cloned.deinit();
try std.testing.expectEqual(inst.epochMilliseconds(), cloned.epochMilliseconds());
}
test "instant toString produces output" {
const inst = try Instant.fromEpochMilliseconds(0);
defer inst.deinit();
const allocator = std.testing.allocator;
const out = try inst.toString(allocator, .{});
defer allocator.free(out);
try std.testing.expect(out.len > 0);
}
test toString {
const epoch_ms: i64 = 1704067200000; // 2024-01-01 00:00:00 UTC
const inst = try Instant.init(epoch_ms);
defer inst.deinit();
const allocator = std.testing.allocator;
const instant_str = try inst.toString(allocator, .{});
defer allocator.free(instant_str);
try std.testing.expect(instant_str.len > 0);
}

30
src/main.zig
View file

@ -1,27 +1,15 @@
const std = @import("std");
const temporalz = @import("temporalz");
const Temporal = @import("temporalz");
pub fn main() !void {
// Prints to stderr, ignoring potential errors.
std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
try temporalz.bufferedPrint();
}
const result = try Temporal.Instant.init(1704067200000); // 2024-01-01 00:00:00 UTC
defer result.deinit();
test "simple test" {
const gpa = std.testing.allocator;
var list: std.ArrayList(i32) = .empty;
defer list.deinit(gpa); // Try commenting this out and see if zig detects the memory leak!
try list.append(gpa, 42);
try std.testing.expectEqual(@as(i32, 42), list.pop());
}
std.debug.print("Instant with Epoch: {}ms\n", .{result.epoch});
test "fuzz example" {
const Context = struct {
fn testOne(context: @This(), input: []const u8) anyerror!void {
_ = context;
// Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input));
}
};
try std.testing.fuzz(Context{}, Context.testOne, .{});
const cloned = result.clone();
std.debug.print("Is Instant Equal: {}\n", .{cloned.equals(result)});
const instant_str = try cloned.toString(std.heap.page_allocator, .{});
std.debug.print("Cloned Instant String: {s}\n", .{instant_str});
}

42
src/root.zig
View file

@ -1,23 +1,31 @@
//! By convention, root.zig is the root source file when making a library.
const std = @import("std");
pub const Instant = @import("Instant.zig");
pub fn bufferedPrint() !void {
// Stdout is for the actual output of your application, for example if you
// are implementing gzip, then only the compressed bytes should be sent to
// stdout, not any debugging messages.
var stdout_buffer: [1024]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
const stdout = &stdout_writer.interface;
test "Instant.methods" {
const instant = @import("Instant.zig");
try stdout.print("Run `zig build test` to run the tests.\n", .{});
const checks = .{
.{ .name = "add", .expect = true },
.{ .name = "equals", .expect = true },
.{ .name = "round", .expect = true },
.{ .name = "since", .expect = true },
.{ .name = "subtract", .expect = true },
.{ .name = "toString", .expect = true },
.{ .name = "toZonedDateTimeIso", .expect = true },
.{ .name = "until", .expect = true },
try stdout.flush(); // Don't forget to flush!
// Not yet implemented aliases from the Temporal JS API.
.{ .name = "toJSON", .expect = false },
.{ .name = "toLocaleString", .expect = false },
.{ .name = "valueOf", .expect = false },
.{ .name = "toZonedDateTimeISO", .expect = false }, // different casing
};
inline for (checks) |check| {
const has = @hasDecl(instant, check.name);
if (check.expect)
try std.testing.expect(has)
else
try std.testing.expect(!has);
}
pub fn add(a: i32, b: i32) i32 {
return a + b;
}
test "basic add functionality" {
try std.testing.expect(add(3, 7) == 10);
}