@mablock/status 0.0.1

package/dist/index.cjs

@@ -0,0 +1,733 @@
+'use strict';
+
+// src/status-code.ts
+var StatusCode = {
+  OK: "OK",
+  CANCELLED: "CANCELLED",
+  UNKNOWN: "UNKNOWN",
+  INVALID_ARGUMENT: "INVALID_ARGUMENT",
+  DEADLINE_EXCEEDED: "DEADLINE_EXCEEDED",
+  NOT_FOUND: "NOT_FOUND",
+  ALREADY_EXISTS: "ALREADY_EXISTS",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  RESOURCE_EXHAUSTED: "RESOURCE_EXHAUSTED",
+  FAILED_PRECONDITION: "FAILED_PRECONDITION",
+  ABORTED: "ABORTED",
+  OUT_OF_RANGE: "OUT_OF_RANGE",
+  UNIMPLEMENTED: "UNIMPLEMENTED",
+  INTERNAL: "INTERNAL",
+  UNAVAILABLE: "UNAVAILABLE",
+  DATA_LOSS: "DATA_LOSS",
+  UNAUTHENTICATED: "UNAUTHENTICATED"
+};
+
+// src/errors.ts
+var StatusError = class extends Error {
+  status;
+  constructor(status) {
+    super(status.toString());
+    this.name = "StatusError";
+    this.status = status;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  get code() {
+    return this.status.code();
+  }
+};
+
+// src/status.ts
+function copyPayload(value) {
+  return typeof value === "string" ? value : value.slice();
+}
+function bytesToBase64(bytes) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let result = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    result += chars[b0 >> 2 & 63];
+    result += chars[(b0 & 3) << 4 | b1 >> 4 & 15];
+    result += i + 1 < bytes.length ? chars[(b1 & 15) << 2 | b2 >> 6 & 3] : "=";
+    result += i + 2 < bytes.length ? chars[b2 & 63] : "=";
+  }
+  return result;
+}
+var Status = class _Status {
+  _code;
+  _message;
+  _payloads;
+  constructor(code = StatusCode.OK, message = "") {
+    this._code = code;
+    this._message = code === StatusCode.OK ? "" : message;
+  }
+  ok() {
+    return this._code === StatusCode.OK;
+  }
+  code() {
+    return this._code;
+  }
+  message() {
+    return this._message;
+  }
+  status() {
+    return this;
+  }
+  setMessage(message) {
+    if (!this.ok()) this._message = message;
+  }
+  toString() {
+    if (this.ok()) return "OK";
+    return this._message.length === 0 ? this._code : `${this._code}: ${this._message}`;
+  }
+  /** Keeps the first non-OK status, matching absl::Status::Update. */
+  update(other) {
+    if (!this.ok()) return this;
+    this._code = other._code;
+    this._message = other._message;
+    this._payloads = other.copyPayloads();
+    return this;
+  }
+  setPayload(typeUrl, payload) {
+    if (this.ok()) return;
+    this._payloads ??= /* @__PURE__ */ new Map();
+    this._payloads.set(typeUrl, copyPayload(payload));
+  }
+  getPayload(typeUrl) {
+    const payload = this._payloads?.get(typeUrl);
+    return payload === void 0 ? void 0 : copyPayload(payload);
+  }
+  hasPayload(typeUrl) {
+    return this._payloads?.has(typeUrl) ?? false;
+  }
+  erasePayload(typeUrl) {
+    if (!this._payloads) return false;
+    const deleted = this._payloads.delete(typeUrl);
+    if (this._payloads.size === 0) this._payloads = void 0;
+    return deleted;
+  }
+  clearPayloads() {
+    this._payloads = void 0;
+  }
+  payloadCount() {
+    return this._payloads?.size ?? 0;
+  }
+  forEachPayload(callback) {
+    if (!this._payloads) return;
+    for (const [key, value] of this._payloads)
+      callback(key, copyPayload(value));
+  }
+  clone() {
+    const cloned = new _Status(this._code, this._message);
+    cloned._payloads = this.copyPayloads();
+    return cloned;
+  }
+  equals(other) {
+    if (!(other instanceof _Status) || this._code !== other._code || this._message !== other._message)
+      return false;
+    if (this.payloadCount() !== other.payloadCount()) return false;
+    if (!this._payloads) return true;
+    for (const [key, value] of this._payloads) {
+      const otherValue = other._payloads?.get(key);
+      if (otherValue === void 0 || !payloadEquals(value, otherValue))
+        return false;
+    }
+    return true;
+  }
+  toJSON() {
+    const json = {
+      ok: this.ok(),
+      code: this._code,
+      message: this._message
+    };
+    if (this._payloads?.size) {
+      const payloads = {};
+      for (const [key, value] of this._payloads)
+        payloads[key] = typeof value === "string" ? value : bytesToBase64(value);
+      json.payloads = payloads;
+    }
+    return json;
+  }
+  toError() {
+    return new StatusError(this.clone());
+  }
+  /** Supports `yield* status` in statusDo pipelines. */
+  *[Symbol.iterator]() {
+    if (this.ok()) return;
+    yield this;
+  }
+  static ok() {
+    return new _Status();
+  }
+  static fromCode(code, message = "", payloads) {
+    const status = new _Status(code, message);
+    if (payloads) applyPayloads(status, payloads);
+    return status;
+  }
+  copyPayloads() {
+    if (!this._payloads?.size) return void 0;
+    return new Map(
+      Array.from(this._payloads, ([key, value]) => [
+        key,
+        copyPayload(value)
+      ])
+    );
+  }
+};
+function payloadEquals(left, right) {
+  if (typeof left === "string" || typeof right === "string")
+    return typeof left === "string" && typeof right === "string" && left === right;
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+function applyPayloads(status, payloads) {
+  if (isReadonlyMap(payloads)) {
+    for (const [key, value] of payloads)
+      status.setPayload(key, value);
+    return;
+  }
+  for (const [key, value] of Object.entries(payloads))
+    status.setPayload(key, value);
+}
+function isReadonlyMap(value) {
+  const candidate = value;
+  return typeof candidate.entries === "function" && typeof candidate[Symbol.iterator] === "function";
+}
+function OkStatus() {
+  return Status.ok();
+}
+function createErrorHelper(code) {
+  return (message = "", payloads) => {
+    const status = new Status(code, message);
+    if (payloads) applyPayloads(status, payloads);
+    return status;
+  };
+}
+var CancelledError = createErrorHelper(StatusCode.CANCELLED);
+var UnknownError = createErrorHelper(StatusCode.UNKNOWN);
+var InvalidArgumentError = createErrorHelper(
+  StatusCode.INVALID_ARGUMENT
+);
+var DeadlineExceededError = createErrorHelper(
+  StatusCode.DEADLINE_EXCEEDED
+);
+var NotFoundError = createErrorHelper(StatusCode.NOT_FOUND);
+var AlreadyExistsError = createErrorHelper(
+  StatusCode.ALREADY_EXISTS
+);
+var PermissionDeniedError = createErrorHelper(
+  StatusCode.PERMISSION_DENIED
+);
+var ResourceExhaustedError = createErrorHelper(
+  StatusCode.RESOURCE_EXHAUSTED
+);
+var FailedPreconditionError = createErrorHelper(
+  StatusCode.FAILED_PRECONDITION
+);
+var AbortedError = createErrorHelper(StatusCode.ABORTED);
+var OutOfRangeError = createErrorHelper(
+  StatusCode.OUT_OF_RANGE
+);
+var UnimplementedError = createErrorHelper(
+  StatusCode.UNIMPLEMENTED
+);
+var InternalError = createErrorHelper(StatusCode.INTERNAL);
+var UnavailableError = createErrorHelper(
+  StatusCode.UNAVAILABLE
+);
+var DataLossError = createErrorHelper(StatusCode.DATA_LOSS);
+var UnauthenticatedError = createErrorHelper(
+  StatusCode.UNAUTHENTICATED
+);
+
+// src/failure-brand.ts
+var FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("absl.status.failure");
+function getBrandedFailureStatus(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null)
+    return void 0;
+  try {
+    if (!(FAILURE_SYMBOL in value)) return void 0;
+    const status = value[FAILURE_SYMBOL];
+    return status instanceof Status && !status.ok() ? status : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/status-or.ts
+var StatusOr = class _StatusOr {
+  _status;
+  _value;
+  constructor(status, value) {
+    this._status = status;
+    this._value = value;
+  }
+  static ok(value) {
+    const failureStatus = getBrandedFailureStatus(value);
+    if (failureStatus) return _StatusOr.fromStatus(failureStatus);
+    return new _StatusOr(Status.ok(), value);
+  }
+  static fromStatus(status) {
+    if (status.ok())
+      throw new RangeError(
+        "StatusOr cannot be constructed from an OK Status without a value"
+      );
+    return new _StatusOr(status.clone());
+  }
+  static all(values) {
+    const results = [];
+    for (const item of values) {
+      const failureStatus = getBrandedFailureStatus(item);
+      if (failureStatus) return _StatusOr.fromStatus(failureStatus);
+      if (item instanceof _StatusOr) {
+        if (!item.ok()) return _StatusOr.fromStatus(item.status());
+        results.push(item._value);
+      } else {
+        results.push(item);
+      }
+    }
+    return _StatusOr.ok(
+      results
+    );
+  }
+  ok() {
+    return this._status.ok();
+  }
+  code() {
+    return this._status.code();
+  }
+  message() {
+    return this._status.message();
+  }
+  status() {
+    return this._status.clone();
+  }
+  value() {
+    if (!this.ok()) throw this._status.toError();
+    return this._value;
+  }
+  valueOr(defaultValue) {
+    return this.ok() ? this._value : defaultValue;
+  }
+  valueOrCompute(computeFallback) {
+    return this.ok() ? this._value : computeFallback(this._status.clone());
+  }
+  transform(fn) {
+    return this.ok() ? _StatusOr.ok(fn(this._value)) : _StatusOr.fromStatus(this._status);
+  }
+  andThen(fn) {
+    return this.ok() ? fn(this._value) : _StatusOr.fromStatus(this._status);
+  }
+  match(handlers) {
+    return this.ok() ? handlers.ok(this._value) : handlers.err(this._status.clone());
+  }
+  *[Symbol.iterator]() {
+    if (this.ok()) return this._value;
+    yield this._status.clone();
+    return void 0;
+  }
+  toString() {
+    if (!this.ok()) return this._status.toString();
+    if (this._value === void 0) return "OK";
+    try {
+      return `OK: ${JSON.stringify(this._value)}`;
+    } catch {
+      return "OK: [unserializable value]";
+    }
+  }
+  toJSON() {
+    if (!this.ok()) return this._status.toJSON();
+    return {
+      ok: true,
+      code: this._status.code(),
+      message: "",
+      value: this._value
+    };
+  }
+  clone() {
+    return this.ok() ? _StatusOr.ok(this._value) : _StatusOr.fromStatus(this._status);
+  }
+  equals(other) {
+    if (!(other instanceof _StatusOr) || this.ok() !== other.ok())
+      return false;
+    if (!this.ok()) return this._status.equals(other._status);
+    return Object.is(this._value, other._value);
+  }
+};
+function statusOr(value) {
+  return StatusOr.ok(value);
+}
+function statusOrError(status) {
+  return StatusOr.fromStatus(status);
+}
+
+// src/sentinel.ts
+function isFailureSentinel(value) {
+  if (!getBrandedFailureStatus(value)) return false;
+  try {
+    const candidate = value;
+    return typeof candidate.ok === "function" && typeof candidate.status === "function" && typeof candidate.code === "function" && typeof candidate.message === "function" && typeof candidate.toString === "function";
+  } catch {
+    return false;
+  }
+}
+function getFailureStatus(value) {
+  const brandedStatus = getBrandedFailureStatus(value);
+  if (brandedStatus) return brandedStatus;
+  if (value instanceof Status) {
+    if (!value.ok()) return value;
+    return void 0;
+  }
+  if (value instanceof StatusOr) {
+    if (!value.ok()) return value.status();
+    return void 0;
+  }
+  return void 0;
+}
+function failure(status) {
+  if (status.ok())
+    throw new RangeError(
+      "Failure sentinel cannot be created from an OK Status"
+    );
+  const base = {
+    [FAILURE_SYMBOL]: status,
+    ok() {
+      return false;
+    },
+    status() {
+      return status;
+    },
+    code() {
+      return status.code();
+    },
+    message() {
+      return status.message();
+    },
+    toString() {
+      return status.toString();
+    },
+    *[Symbol.iterator]() {
+      return throwFailureMisuse(
+        status,
+        "iterate the failed result without ensureOk()"
+      );
+    }
+  };
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (prop in target || prop === FAILURE_SYMBOL)
+        return Reflect.get(target, prop, receiver);
+      if (prop === "then") return void 0;
+      if (prop === Symbol.toPrimitive)
+        return () => throwFailureMisuse(
+          status,
+          "coerce the failed result to a primitive"
+        );
+      if (typeof prop === "symbol") return void 0;
+      return throwFailureMisuse(
+        status,
+        `read business property ${JSON.stringify(prop)}`
+      );
+    },
+    set(_target, prop) {
+      return throwFailureMisuse(
+        status,
+        `write business property ${JSON.stringify(String(prop))}`
+      );
+    },
+    deleteProperty(_target, prop) {
+      return throwFailureMisuse(
+        status,
+        `delete business property ${JSON.stringify(String(prop))}`
+      );
+    },
+    defineProperty(_target, prop) {
+      return throwFailureMisuse(
+        status,
+        `define business property ${JSON.stringify(String(prop))}`
+      );
+    },
+    has(target, prop) {
+      if (prop in target) return true;
+      if (prop === "then" || typeof prop === "symbol") return false;
+      return throwFailureMisuse(
+        status,
+        `check business property ${JSON.stringify(prop)}`
+      );
+    },
+    ownKeys() {
+      return throwFailureMisuse(
+        status,
+        "enumerate or spread the failed result"
+      );
+    }
+  });
+}
+function throwFailureMisuse(status, action) {
+  const error = new StatusError(status.clone());
+  error.message = `Failure result used as a successful value: attempted to ${action}. Check it with hasError() or ensureOk() first. Original status: ${status.toString()}`;
+  throw error;
+}
+var failureSentinel = failure;
+var createFailure = failure;
+function asProxy(statusOr2) {
+  return new Proxy(statusOr2, {
+    get(target, prop, receiver) {
+      if (prop in target || typeof prop === "symbol") {
+        const val = Reflect.get(target, prop, receiver);
+        if (typeof val === "function") return val.bind(target);
+        return val;
+      }
+      if (target.ok()) {
+        const inner = target.value();
+        if (inner !== null && inner !== void 0 && (typeof inner === "object" || typeof inner === "function")) {
+          const val = Reflect.get(inner, prop, inner);
+          if (typeof val === "function") return val.bind(inner);
+          return val;
+        }
+      }
+      return void 0;
+    },
+    has(target, prop) {
+      if (prop in target) return true;
+      if (target.ok()) {
+        const inner = target.value();
+        if (inner !== null && inner !== void 0 && (typeof inner === "object" || typeof inner === "function"))
+          return prop in inner;
+      }
+      return false;
+    }
+  });
+}
+
+// src/do.ts
+function* ensureOk(target) {
+  if (target instanceof Status) {
+    if (!target.ok()) yield target;
+    return void 0;
+  }
+  if (target instanceof StatusOr) {
+    if (!target.ok()) yield target.status();
+    return target.value();
+  }
+  if (isFailureSentinel(target)) {
+    yield target[FAILURE_SYMBOL];
+    return void 0;
+  }
+  return target;
+}
+var EnsureOk = ensureOk;
+var checkStatus = ensureOk;
+var CheckStatus = ensureOk;
+function statusDo(generatorFn) {
+  const iterator = generatorFn();
+  const step = iterator.next();
+  if (!step.done) {
+    try {
+      if (isFailureSentinel(step.value))
+        return StatusOr.fromStatus(step.value[FAILURE_SYMBOL]);
+      return StatusOr.fromStatus(step.value);
+    } finally {
+      iterator.return?.(void 0);
+    }
+  }
+  return normalizeResult(step.value, "statusDo");
+}
+async function statusDoAsync(generatorFn) {
+  const iterator = generatorFn();
+  const step = await iterator.next();
+  if (!step.done) {
+    try {
+      if (isFailureSentinel(step.value))
+        return StatusOr.fromStatus(step.value[FAILURE_SYMBOL]);
+      return StatusOr.fromStatus(step.value);
+    } finally {
+      await iterator.return?.(void 0);
+    }
+  }
+  return normalizeResult(step.value, "statusDoAsync");
+}
+function normalizeResult(result, source) {
+  if (result instanceof StatusOr) return result;
+  if (isFailureSentinel(result))
+    return StatusOr.fromStatus(result[FAILURE_SYMBOL]);
+  if (result instanceof Status) {
+    if (result.ok())
+      return StatusOr.fromStatus(
+        InternalError(
+          `${source} cannot return an OK Status without a value`
+        )
+      );
+    return StatusOr.fromStatus(result);
+  }
+  return StatusOr.ok(result);
+}
+
+// src/predicates.ts
+function extractStatusCode(target) {
+  if (target === null || target === void 0) return void 0;
+  if (target instanceof Status || target instanceof StatusOr)
+    return target.code();
+  if (typeof target.code === "function") {
+    const res = target.code();
+    if (isStatusCode(res)) return res;
+  }
+  if (isStatusCode(target.code))
+    return target.code;
+  return void 0;
+}
+var statusCodes = new Set(Object.values(StatusCode));
+function isStatusCode(value) {
+  return typeof value === "string" && statusCodes.has(value);
+}
+function isOk(target) {
+  const code = extractStatusCode(target);
+  if (code === void 0) return false;
+  return code === StatusCode.OK;
+}
+function hasError(target) {
+  if (target === null || target === void 0) return false;
+  if (target instanceof Status) return !target.ok();
+  if (target instanceof StatusOr) return !target.ok();
+  if (isFailureSentinel(target)) return true;
+  return false;
+}
+function createPredicate(expectedCode) {
+  return (target) => {
+    const code = extractStatusCode(target);
+    if (code === void 0) return false;
+    return code === expectedCode;
+  };
+}
+var isCancelled = createPredicate(StatusCode.CANCELLED);
+var isUnknown = createPredicate(StatusCode.UNKNOWN);
+var isInvalidArgument = createPredicate(
+  StatusCode.INVALID_ARGUMENT
+);
+var isDeadlineExceeded = createPredicate(
+  StatusCode.DEADLINE_EXCEEDED
+);
+var isNotFound = createPredicate(StatusCode.NOT_FOUND);
+var isAlreadyExists = createPredicate(
+  StatusCode.ALREADY_EXISTS
+);
+var isPermissionDenied = createPredicate(
+  StatusCode.PERMISSION_DENIED
+);
+var isResourceExhausted = createPredicate(
+  StatusCode.RESOURCE_EXHAUSTED
+);
+var isFailedPrecondition = createPredicate(
+  StatusCode.FAILED_PRECONDITION
+);
+var isAborted = createPredicate(StatusCode.ABORTED);
+var isOutOfRange = createPredicate(StatusCode.OUT_OF_RANGE);
+var isUnimplemented = createPredicate(
+  StatusCode.UNIMPLEMENTED
+);
+var isInternal = createPredicate(StatusCode.INTERNAL);
+var isUnavailable = createPredicate(StatusCode.UNAVAILABLE);
+var isDataLoss = createPredicate(StatusCode.DATA_LOSS);
+var isUnauthenticated = createPredicate(
+  StatusCode.UNAUTHENTICATED
+);
+
+// src/interop.ts
+function fromError(error) {
+  const failureStatus = getBrandedFailureStatus(error);
+  if (failureStatus) return failureStatus;
+  if (error instanceof Status)
+    return error.ok() ? InternalError("Caught an OK Status as an error") : error;
+  if (error instanceof StatusError)
+    return error.status.ok() ? InternalError("Caught a StatusError containing an OK Status") : error.status;
+  if (error instanceof RangeError)
+    return OutOfRangeError(error.message);
+  if (error instanceof TypeError)
+    return InvalidArgumentError(error.message);
+  if (error instanceof Error) return UnknownError(error.message);
+  if (typeof error === "string") return UnknownError(error);
+  return UnknownError(String(error));
+}
+function tryCatch(fn, mapper) {
+  try {
+    return StatusOr.ok(fn());
+  } catch (err) {
+    const status = mapper ? mapper(err) : fromError(err);
+    return StatusOr.fromStatus(
+      status.ok() ? InternalError("tryCatch mapper returned an OK Status") : status
+    );
+  }
+}
+async function tryCatchAsync(fn, mapper) {
+  try {
+    return StatusOr.ok(await fn());
+  } catch (err) {
+    const status = mapper ? mapper(err) : fromError(err);
+    return StatusOr.fromStatus(
+      status.ok() ? InternalError("tryCatchAsync mapper returned an OK Status") : status
+    );
+  }
+}
+
+exports.AbortedError = AbortedError;
+exports.AlreadyExistsError = AlreadyExistsError;
+exports.CancelledError = CancelledError;
+exports.CheckStatus = CheckStatus;
+exports.DataLossError = DataLossError;
+exports.DeadlineExceededError = DeadlineExceededError;
+exports.EnsureOk = EnsureOk;
+exports.FAILURE_SYMBOL = FAILURE_SYMBOL;
+exports.FailedPreconditionError = FailedPreconditionError;
+exports.InternalError = InternalError;
+exports.InvalidArgumentError = InvalidArgumentError;
+exports.NotFoundError = NotFoundError;
+exports.OkStatus = OkStatus;
+exports.OutOfRangeError = OutOfRangeError;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.ResourceExhaustedError = ResourceExhaustedError;
+exports.Status = Status;
+exports.StatusCode = StatusCode;
+exports.StatusError = StatusError;
+exports.StatusOr = StatusOr;
+exports.UnauthenticatedError = UnauthenticatedError;
+exports.UnavailableError = UnavailableError;
+exports.UnimplementedError = UnimplementedError;
+exports.UnknownError = UnknownError;
+exports.asProxy = asProxy;
+exports.checkStatus = checkStatus;
+exports.createFailure = createFailure;
+exports.ensureOk = ensureOk;
+exports.failure = failure;
+exports.failureSentinel = failureSentinel;
+exports.fromError = fromError;
+exports.getFailureStatus = getFailureStatus;
+exports.hasError = hasError;
+exports.isAborted = isAborted;
+exports.isAlreadyExists = isAlreadyExists;
+exports.isCancelled = isCancelled;
+exports.isDataLoss = isDataLoss;
+exports.isDeadlineExceeded = isDeadlineExceeded;
+exports.isFailedPrecondition = isFailedPrecondition;
+exports.isFailureSentinel = isFailureSentinel;
+exports.isInternal = isInternal;
+exports.isInvalidArgument = isInvalidArgument;
+exports.isNotFound = isNotFound;
+exports.isOk = isOk;
+exports.isOutOfRange = isOutOfRange;
+exports.isPermissionDenied = isPermissionDenied;
+exports.isResourceExhausted = isResourceExhausted;
+exports.isUnauthenticated = isUnauthenticated;
+exports.isUnavailable = isUnavailable;
+exports.isUnimplemented = isUnimplemented;
+exports.isUnknown = isUnknown;
+exports.statusDo = statusDo;
+exports.statusDoAsync = statusDoAsync;
+exports.statusOr = statusOr;
+exports.statusOrError = statusOrError;
+exports.tryCatch = tryCatch;
+exports.tryCatchAsync = tryCatchAsync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map