@replohq/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,11 @@
+Replo SDK — proprietary software of Replo. All rights reserved.
+
+This software is licensed, not sold. Subject to the Replo Terms of Service
+(https://replo.app/terms), Replo grants you a limited, non-exclusive,
+non-transferable, revocable license to install and use this software solely to
+build, preview, and operate sites on the Replo platform. You may not
+redistribute, resell, sublicense, or use this software to build or operate any
+product or service independent of or competing with Replo.
+
+Full terms: https://replo.app/terms
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

package/_vendor/replo-utils/lib/crypto.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Web Crypto helpers shared across runtime targets (Cloudflare Workers, Node
+ * 19+, browsers). Built on `crypto.subtle` so the same implementation runs
+ * inside Workers without a Node-only `node:crypto` import.
+ */
+export declare function bytesToBase64Url(bytes: Uint8Array): string;
+export declare function base64UrlToBytes(input: string): Uint8Array;
+export declare function randomBase64Url(byteLength: number): string;
+/**
+ * Prefer this over the global `crypto.randomUUID()`, which is secure-context-only
+ * and therefore undefined over plain `http://`. `uuid`'s v4 is backed by
+ * `crypto.getRandomValues`, which carries no such restriction.
+ */
+export declare function randomUUID(): string;
+/**
+ * Returns the SHA-256 of `input` as a 64-char lowercase hex string.
+ *
+ * Used for storing opaque secrets (e.g. public API tokens) where we want
+ * constant-length hex output suitable for a `VARCHAR(64)` column with a
+ * unique index.
+ */
+export declare function sha256Hex(input: string): Promise<string>;
+export declare function constantTimeEqual({ left, right, }: {
+    left: Uint8Array;
+    right: Uint8Array;
+}): boolean;
+export declare function getHmacSha256Hex({ rawBody, signingKey, }: {
+    rawBody: string;
+    signingKey: string;
+}): Promise<string>;

package/_vendor/replo-utils/lib/errors.d.ts

@@ -0,0 +1,83 @@
+type ValueOfType<ObjectType> = ObjectType[keyof ObjectType];
+/**
+ * Mostly taken from
+ * https://gist.githubusercontent.com/scokmen/f813c904ef79022e84ab2409574d1b45/raw/cd8709a2fccb005bb53e9bfb2461e07d40b4e8d8/HttpStatusCode.ts
+ */
+export declare const HTTP_STATUS_CODES: {
+    readonly CONTINUE: 100;
+    readonly SWITCHING_PROTOCOLS: 101;
+    readonly PROCESSING: 102;
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly ACCEPTED: 202;
+    readonly NON_AUTHORITATIVE_INFORMATION: 203;
+    readonly NO_CONTENT: 204;
+    readonly RESET_CONTENT: 205;
+    readonly PARTIAL_CONTENT: 206;
+    readonly MULTI_STATUS: 207;
+    readonly ALREADY_REPORTED: 208;
+    readonly IM_USED: 226;
+    readonly MULTIPLE_CHOICES: 300;
+    readonly MOVED_PERMANENTLY: 301;
+    readonly FOUND: 302;
+    readonly SEE_OTHER: 303;
+    readonly NOT_MODIFIED: 304;
+    readonly USE_PROXY: 305;
+    readonly SWITCH_PROXY: 306;
+    readonly TEMPORARY_REDIRECT: 307;
+    readonly PERMANENT_REDIRECT: 308;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly PAYMENT_REQUIRED: 402;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly NOT_ACCEPTABLE: 406;
+    readonly PROXY_AUTHENTICATION_REQUIRED: 407;
+    readonly REQUEST_TIMEOUT: 408;
+    readonly CONFLICT: 409;
+    readonly GONE: 410;
+    readonly LENGTH_REQUIRED: 411;
+    readonly PRECONDITION_FAILED: 412;
+    readonly PAYLOAD_TOO_LARGE: 413;
+    readonly URI_TOO_LONG: 414;
+    readonly UNSUPPORTED_MEDIA_TYPE: 415;
+    readonly RANGE_NOT_SATISFIABLE: 416;
+    readonly EXPECTATION_FAILED: 417;
+    readonly I_AM_A_TEAPOT: 418;
+    readonly MISDIRECTED_REQUEST: 421;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly LOCKED: 423;
+    readonly FAILED_DEPENDENCY: 424;
+    readonly UPGRADE_REQUIRED: 426;
+    readonly PRECONDITION_REQUIRED: 428;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
+    readonly UNAVAILABLE_FOR_LEGAL_REASONS: 451;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+    readonly HTTP_VERSION_NOT_SUPPORTED: 505;
+    readonly VARIANT_ALSO_NEGOTIATES: 506;
+    readonly INSUFFICIENT_STORAGE: 507;
+    readonly LOOP_DETECTED: 508;
+    readonly NOT_EXTENDED: 510;
+    readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
+    readonly UPSTREAM_WEBSERVER_ERROR: 520;
+};
+export type HttpStatusCode = ValueOfType<typeof HTTP_STATUS_CODES>;
+/**
+ * Checks if an error message indicates a network error (e.g., connectivity issues,
+ * request timeouts, DNS failures). These errors typically don't need to be tracked
+ * in error monitoring systems like Sentry since they're user-side connectivity issues.
+ */
+export declare function isNetworkErrorMessage(message: string): boolean;
+/**
+ * Extracts a human-readable message from an unknown caught value. If the value
+ * is an Error, returns its message; otherwise falls back to the provided
+ * fallback string or `String(error)`.
+ */
+export declare function getErrorMessage(error: unknown, fallback?: string): string;
+export {};

package/_vendor/replo-utils/lib/json.d.ts

@@ -0,0 +1,6 @@
+export declare function parseJsonOrNull(json: string): unknown | null;
+export declare function omitJsonObjectFieldsOrNull({ json, fields, }: {
+    json: string;
+    fields: string[];
+}): string | null;
+export declare function jsonStringifyOrNull(value: unknown): string | null;

package/_vendor/replo-utils/lib/json.mjs

@@ -0,0 +1,43 @@
+import '../../../chunk-UJCSKKID.mjs';
+
+// ../replo-utils/lib/object.ts
+function omit(obj, keysToOmit) {
+  const result = { ...obj };
+  for (const key of keysToOmit) {
+    delete result[key];
+  }
+  return result;
+}
+
+// ../replo-utils/lib/json.ts
+function parseJsonOrNull(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function omitJsonObjectFieldsOrNull({
+  json,
+  fields
+}) {
+  const parsedJson = parseJsonOrNull(json);
+  if (typeof parsedJson !== "object" || parsedJson === null || Array.isArray(parsedJson)) {
+    return null;
+  }
+  return jsonStringifyOrNull(
+    omit(Object.fromEntries(Object.entries(parsedJson)), fields)
+  );
+}
+function jsonStringifyOrNull(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+
+export { jsonStringifyOrNull, omitJsonObjectFieldsOrNull, parseJsonOrNull };

package/_vendor/replo-utils/lib/misc.d.ts

@@ -0,0 +1,145 @@
+import isFunction from "lodash-es/isFunction";
+import isNumber from "lodash-es/isNumber";
+import isString from "lodash-es/isString";
+export { isFunction, isNumber, isString };
+/**
+ * Checks if a value is neither `null` nor `undefined`.
+ */
+export declare function isNotNullish<ValueType>(value: ValueType): value is Exclude<ValueType, null | undefined>;
+/**
+ * Checks if a value is either `null` or `undefined`.
+ */
+export declare function isNullish(value: unknown): value is null | undefined;
+export declare function getFromRecordOrNull<RecordKey extends PropertyKey, RecordValue>(record: Record<RecordKey, RecordValue> | null | undefined, key: RecordKey | undefined | null): NonNullable<Record<RecordKey, RecordValue>[RecordKey]> | null;
+export declare function isPrimitive(value: unknown): value is string | number | boolean;
+type StructureRecord<UnionType extends {
+    type: string;
+}, ResultType> = {
+    [MemberType in UnionType as MemberType["type"]]: ResultType | ((value: MemberType) => ResultType);
+};
+type StructureRecordBareString<UnionType extends string, ResultType> = {
+    [MemberType in UnionType]: ResultType | ((value: MemberType) => ResultType);
+};
+type StructureRecordGeneric<UnionType extends Record<KeyType, string>, ResultType, KeyType extends keyof UnionType> = {
+    [MemberType in UnionType as MemberType[KeyType]]: ResultType | ((value: MemberType) => ResultType);
+};
+/**
+ * @returns A function which can be used to create an exhaustive switch over all
+ * types of a discriminated union, based on a given key, or over all members of
+ * a bare string union.
+ *
+ * When no key is provided, it defaults to using "type" as the discriminant.
+ * When the value is a bare string union, the value is its own discriminant.
+ *
+ * Examples:
+ *
+ * With default "type" discriminant:
+ * ```
+ * type OneOrTwo = { type: "one", numberValue: number } |
+ * { type: "two", stringValue: string }
+ *
+ * let oneOrTwo = ...
+ * let result = exhaustiveSwitch(oneOrTwo)({
+ * one: (op) => `${op.numberValue + 1}`, // Typescript knows numberValue is a number
+ * two: (op) => op.stringValue + "hello", // Typescript knows stringValue is a string
+ * }) // type of result is inferred to be string
+ * ```
+ *
+ * With custom discriminant key:
+ * ```
+ * type OneOrTwo = { variant: "one", numberValue: number } |
+ * { variant: "two", stringValue: string }
+ *
+ * let oneOrTwo = ...
+ * let result = exhaustiveSwitch(oneOrTwo, "variant")({
+ * one: (op) => `${op.numberValue + 1}`, // Typescript knows numberValue is a number
+ * two: (op) => op.stringValue + "hello", // Typescript knows stringValue is a string
+ * }) // type of result is inferred to be string
+ * ```
+ *
+ * With a bare string union:
+ * ```
+ * type OneOrTwo = "one" | "two"
+ *
+ * let oneOrTwo = ...
+ * let result = exhaustiveSwitch(oneOrTwo)({
+ * one: 1, // cases can be plain values...
+ * two: () => 1 + 1, // ...or functions, evaluated lazily
+ * }) // type of result is inferred to be number
+ * ```
+ *
+ * Typescript will error if you forget a case, or if you assume the wrong type
+ * for a case value. The switch also returns the value you return from the
+ * function mapping, so it works well for "extension" methods where you want to
+ * map over all discriminated union cases and do a different thing for each.
+ *
+ * Works well for many of our types, like ComponentActionType, Action, etc
+ */
+export declare function exhaustiveSwitch<UnionType extends string>(value: UnionType): <ResultType>(cases: StructureRecordBareString<UnionType, ResultType>) => ResultType;
+export declare function exhaustiveSwitch<UnionType extends {
+    type: string;
+}>(value: UnionType): <ResultType>(cases: StructureRecord<UnionType, ResultType>) => ResultType;
+export declare function exhaustiveSwitch<UnionType extends Record<KeyType, string>, KeyType extends keyof UnionType>(value: UnionType, key: KeyType): <ResultType>(cases: StructureRecordGeneric<UnionType, ResultType, KeyType>) => ResultType;
+type EmptyObject<ValueType> = {
+    [KeyType in keyof ValueType]?: never;
+};
+type EmptyObjectOf<ValueType> = EmptyObject<ValueType> extends ValueType ? EmptyObject<ValueType> : never;
+/**
+ * The same as `isEmpty` from lodash, but with a few additional overloads for
+ * stronger type-checking on empty arrays.
+ */
+export declare function isEmpty(value: string): value is "";
+export declare function isEmpty<ValueType extends any[]>(value: ValueType | null | undefined): value is (ValueType & []) | null | undefined;
+export declare function isEmpty<ValueType extends ArrayLike<any>>(value: ValueType | null | undefined): value is (ValueType & {
+    length: 0;
+}) | null | undefined;
+export declare function isEmpty(value: Map<any, any> | Set<any> | ArrayLike<any> | null | undefined): boolean;
+export declare function isEmpty(value: object): boolean;
+export declare function isEmpty<ValueType extends object>(value: ValueType | null | undefined): value is EmptyObjectOf<ValueType> | null | undefined;
+export declare function isEmpty(value?: any): boolean;
+export declare function noop(): void;
+export declare function preventDefault(event: {
+    preventDefault(): void;
+}): void;
+/**
+ * Copyright (c) 2019 Alexander Reardon
+ * https://github.com/alexreardon/tiny-warning/blob/master/src/index.js
+ */
+export declare function warning(condition: unknown, message: string | (() => string), options?: {
+    severity: "log" | "warn" | "error";
+}): void;
+/**
+ *
+ * Copyright (c) 2019 Alexander Reardon
+ * https://github.com/alexreardon/tiny-warning/blob/master/src/index.js
+ */
+export declare function invariant(condition: unknown, message: string | (() => string), opts?: {
+    stripErrorMessage: unknown;
+}): asserts condition;
+export declare const mergeReplacingObjects: (first: Object, second: Object) => void;
+export declare const mergeReplacingArrays: (first: Object, second: Object) => void;
+export declare const deepCloneAndMergeReplacingArrays: <ValueType>(source: ValueType, ...toMerge: Object[]) => ValueType;
+/**
+ * hasOwnProperty with a type assertion. If this returns true, typescript knows that `obj`
+ * has a property called `prop` from that point forward
+ * https://fettblog.eu/typescript-hasownproperty/
+ */
+export declare function hasOwnProperty<ObjectType extends {} | null | undefined, KeyType extends PropertyKey>(obj: ObjectType, prop: KeyType): obj is ObjectType & Record<KeyType, unknown>;
+/**
+ * Given a string | number param, converts it to a string, unless it's nullish
+ * in which case it just returns it. Useful for times when you have string | number
+ * | nullish types, like when selecting the current value of a CSS property in a right
+ * bar modifier
+ */
+export declare function coerceNumberToString(value: string | number): string;
+export declare function coerceNumberToString(value: string | number | null | undefined): string | null | undefined;
+export declare function coerceNumberToString(value: string | number | undefined): string | undefined;
+export declare function coerceNumberToString(value: string | number | null): string | null;
+/**
+ * Formats a file size in bytes to a human readable string with appropriate
+ * units. Rounds to 0 decimal places unless otherwise specified and uses
+ * standard binary units (KB, MB, etc).
+ */
+export declare function formatFileSize(byteCount: number, decimalPlaces?: number): string;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function errorMessage(error: unknown): string;

package/_vendor/replo-utils/lib/object.d.ts

@@ -0,0 +1,31 @@
+import { dequal as dequalLite } from "dequal/lite";
+interface ForEachPrimitiveValueArgs {
+    target: Record<string, any> | unknown[] | null;
+    fn: (value: unknown, key: string, newTarget: Record<string, any>) => void;
+    valueConversionFunction?: (transformValue: Record<string, any> | unknown[]) => Record<string, any> | unknown[];
+}
+/** There's probably a bug somewhere here since it assumes target is initially an object */
+export declare function forEachPrimitiveValue({ target, fn, valueConversionFunction, }: ForEachPrimitiveValueArgs): void;
+export declare function shallowEqual(objA: unknown, objB: unknown): boolean;
+/**
+ * Internally we use `dequal` for deep equality checks. It benchmarks faster
+ * than lodash and most other libraries.
+ *
+ * This function is an alias for `dequal`'s "lite" module. It does not check
+ * equality for `Map` or `Set` values. If you need to compare those, use
+ * `deepEqualHeavy`.
+ *
+ * @see https://github.com/lukeed/dequal#modes
+ */
+export declare const deepEqual: typeof dequalLite;
+/**
+ * Creates a new object with specified keys omitted.
+ *
+ * @param obj - The source object
+ * @param keysToOmit - Array of keys to omit from the result
+ * @returns A new object without the specified keys
+ */
+export declare function omit<ObjectType extends Record<string, any>, KeyType extends keyof ObjectType>(obj: ObjectType, keysToOmit: KeyType[]): Omit<ObjectType, KeyType>;
+export declare function filterUndefined<ObjectType extends Record<string, unknown>>(data: ObjectType): Partial<ObjectType>;
+export declare function toNullableIfDefined<ValueType>(value: ValueType | undefined): ValueType | null | undefined;
+export {};