@synnaxlabs/freighter 0.2.0 → 0.4.1

package/.eslintrc.cjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2023 Synnax Labs, Inc.
+ *
+ * Use of this software is governed by the Business Source License included in the file
+ * licenses/BSL.txt.
+ *
+ * As of the Change Date specified in that file, in accordance with the Business Source
+ * License, use of this software will be governed by the Apache License, Version 2.0,
+ * included in the file licenses/APL.txt.
+ */
+
+module.exports = {
+    root: true,
+    extends: ["synnaxlabs"],
+    parserOptions: {
+        project: "./tsconfig.json",
+    },
+};

package/LICENSE

@@ -1,21 +1,4 @@
-MIT License
-
-Copyright (c) 2019 emiliano bonilla
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Source code in this repository is licensed under the Business Source License 1.1 (BSL).
+A copy of the license can be found in the licenses/BSL.txt file. Source code in a given
+file is licensed under the BSL and the copyright belongs to Synnax Labs, Inc. unless
+otherwise noted at the beginning of the file.

package/dist/alamos.d.ts

@@ -0,0 +1,3 @@
+import { type Instrumentation } from "@synnaxlabs/alamos";
+import { type Middleware } from './middleware';
+export declare const middleware: (instrumentation: Instrumentation) => Middleware;

package/{build/module/lib → dist}/errors.d.ts

@@ -1,41 +1,36 @@
-import { z } from 'zod';
+import { URL } from "@synnaxlabs/x";
+import { z } from "zod";
 export interface TypedError extends Error {
-  discriminator: 'FreighterError';
-  /**
-   * @description Returns a unique type identifier for the error. Freighter uses this to
-   * determine the correct decoder to use on the other end of the freighter.
-   */
-  type: string;
+    discriminator: "FreighterError";
+    /**
+     * @description Returns a unique type identifier for the error. Freighter uses this to
+     * determine the correct decoder to use on the other end of the freighter.
+     */
+    type: string;
 }
 export declare class BaseTypedError extends Error implements TypedError {
-  discriminator: 'FreighterError';
-  type: string;
-  constructor(message: string, type: string);
+    discriminator: "FreighterError";
+    type: string;
+    constructor(message: string, type: string);
 }
-declare type ErrorDecoder = (encoded: string) => Error | undefined;
-declare type ErrorEncoder = (error: TypedError) => string;
+type ErrorDecoder = (encoded: ErrorPayload) => Error | null;
+type ErrorEncoder = (error: TypedError) => ErrorPayload | null;
 export declare const isTypedError: (error: unknown) => error is TypedError;
-export declare const assertErrorType: <T>(type: string, error?: Error) => T;
-export declare const UNKNOWN = 'unknown';
-export declare const NONE = 'nil';
-export declare const FREIGHTER = 'freighter';
-export declare const ErrorPayloadSchema: z.ZodObject<
-  {
+export declare const assertErrorType: <T>(type: string, error?: Error | null) => T;
+export declare const UNKNOWN = "unknown";
+export declare const NONE = "nil";
+export declare const FREIGHTER = "freighter";
+export declare const errorZ: z.ZodObject<{
     type: z.ZodString;
     data: z.ZodString;
-  },
-  'strip',
-  z.ZodTypeAny,
-  {
+}, "strip", z.ZodTypeAny, {
     type: string;
     data: string;
-  },
-  {
+}, {
     type: string;
     data: string;
-  }
->;
-export declare type ErrorPayload = z.infer<typeof ErrorPayloadSchema>;
+}>;
+export type ErrorPayload = z.infer<typeof errorZ>;
 /**
  * Registers a custom error type with the error registry, which allows it to be
  * encoded/decoded and sent over the network.
@@ -44,14 +39,9 @@ export declare type ErrorPayload = z.infer<typeof ErrorPayloadSchema>;
  * @param encode - A function that encodes the error into a string.
  * @param decode - A function that decodes the error from a string.
  */
-export declare const registerError: ({
-  type,
-  encode,
-  decode,
-}: {
-  type: string;
-  encode: ErrorEncoder;
-  decode: ErrorDecoder;
+export declare const registerError: ({ encode, decode, }: {
+    encode: ErrorEncoder;
+    decode: ErrorDecoder;
 }) => void;
 /**
  * Encodes an error into a payload that can be sent between a freighter server
@@ -68,20 +58,25 @@ export declare const encodeError: (error: unknown) => ErrorPayload;
  * @param payload - The encoded error payload.
  * @returns The decoded error.
  */
-export declare const decodeError: (payload: ErrorPayload) => Error | undefined;
+export declare const decodeError: (payload: ErrorPayload) => Error | null;
 export declare class UnknownError extends BaseTypedError implements TypedError {
-  constructor(message: string);
+    constructor(message: string);
 }
 /** Thrown/returned when a stream closed normally. */
 export declare class EOF extends BaseTypedError implements TypedError {
-  constructor();
+    constructor();
 }
 /** Thrown/returned when a stream is closed abnormally. */
 export declare class StreamClosed extends BaseTypedError implements TypedError {
-  constructor();
+    constructor();
+}
+export interface UnreachableArgs {
+    message?: string;
+    url?: URL;
 }
 /** Thrown when a target is unreachable. */
 export declare class Unreachable extends BaseTypedError implements TypedError {
-  constructor();
+    url: URL;
+    constructor(args?: UnreachableArgs);
 }
 export {};