@sjcx/vorma 0.0.0-pre.0

package/dist/universal/search-shape.d.ts

@@ -0,0 +1,32 @@
+/** The URL parser's data description, independent of Effect's schema representation. */
+export type SearchScalarKind = "string" | "number" | "boolean" | "bigint" | "date" | "url" | "url-search-params" | "regexp" | "duration" | "big-decimal" | "date-time-utc" | "date-time-zoned";
+type Presence = {
+    readonly optional?: true;
+    readonly nullable?: true;
+};
+export type SearchScalar = Presence & {
+    readonly kind: "scalar";
+    readonly type: SearchScalarKind;
+    readonly values?: ReadonlyArray<string>;
+};
+export type SearchShape = SearchScalar | (Presence & ({
+    readonly kind: "object";
+    readonly fields: Readonly<Record<string, SearchShape>>;
+} | {
+    readonly kind: "array";
+    readonly collection: "array" | "set" | "chunk" | "hash-set";
+    readonly item: SearchScalar;
+} | {
+    readonly kind: "record";
+    readonly collection: "record" | "map" | "hash-map";
+    readonly key: SearchScalar;
+    readonly value: SearchShape;
+} | {
+    readonly kind: "option";
+    readonly value: SearchShape;
+} | {
+    readonly kind: "redacted";
+    readonly value: SearchShape;
+    readonly label?: string;
+}));
+export {};

package/dist/universal/static-assets.d.ts

@@ -0,0 +1,2 @@
+/** Native request destinations for the resource formats that browsers render directly. */
+export declare function getStaticAssetDestination(url: string): "image" | "font" | "fetch";

package/dist/universal/transport-types/big-decimal.d.ts

@@ -0,0 +1,13 @@
+/** Generic BigDecimal value operations, independent of application contracts. */
+export declare const bigDecimalTransportType: {
+    readonly kind: "big-decimal";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => {
+        readonly _tag: "None";
+    } | {
+        readonly _tag: "Some";
+        readonly value: unknown;
+    };
+};

package/dist/universal/transport-types/chunk.d.ts

@@ -0,0 +1,8 @@
+/** Generic Chunk value operations, independent of application contracts. */
+export declare const chunkTransportType: {
+    readonly kind: "chunk";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly getValues: (value: unknown) => ReadonlyArray<unknown>;
+    readonly fromValues: (values: ReadonlyArray<unknown>) => unknown;
+};

package/dist/universal/transport-types/date-time-utc.d.ts

@@ -0,0 +1,13 @@
+/** Generic DateTime value operations, independent of application contracts. */
+export declare const dateTimeUtcTransportType: {
+    readonly kind: "date-time-utc";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => {
+        readonly _tag: "None";
+    } | {
+        readonly _tag: "Some";
+        readonly value: unknown;
+    };
+};

package/dist/universal/transport-types/date-time-zoned.d.ts

@@ -0,0 +1,13 @@
+/** Generic DateTime value operations, independent of application contracts. */
+export declare const dateTimeZonedTransportType: {
+    readonly kind: "date-time-zoned";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => {
+        readonly _tag: "None";
+    } | {
+        readonly _tag: "Some";
+        readonly value: unknown;
+    };
+};

package/dist/universal/transport-types/duration.d.ts

@@ -0,0 +1,13 @@
+/** Generic Duration value operations, independent of application contracts. */
+export declare const durationTransportType: {
+    readonly kind: "duration";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => {
+        readonly _tag: "None";
+    } | {
+        readonly _tag: "Some";
+        readonly value: unknown;
+    };
+};

package/dist/universal/transport-types/hash-map.d.ts

@@ -0,0 +1,8 @@
+/** Generic HashMap value operations, independent of application contracts. */
+export declare const hashMapTransportType: {
+    readonly kind: "hash-map";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly getEntries: (value: unknown) => ReadonlyArray<readonly [unknown, unknown]>;
+    readonly fromEntries: (entries: ReadonlyArray<readonly [unknown, unknown]>) => unknown;
+};

package/dist/universal/transport-types/hash-set.d.ts

@@ -0,0 +1,8 @@
+/** Generic HashSet value operations, independent of application contracts. */
+export declare const hashSetTransportType: {
+    readonly kind: "hash-set";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly getValues: (value: unknown) => ReadonlyArray<unknown>;
+    readonly fromValues: (values: ReadonlyArray<unknown>) => unknown;
+};

package/dist/universal/transport-types/option.d.ts

@@ -0,0 +1,10 @@
+/** Generic Option value operations, independent of application contracts. */
+export declare const optionTransportType: {
+    readonly kind: "option";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly matchesNone: (value: unknown) => boolean;
+    readonly getValue: (value: unknown) => unknown;
+    readonly none: () => unknown;
+    readonly some: (value: unknown) => unknown;
+};

package/dist/universal/transport-types/redacted.d.ts

@@ -0,0 +1,9 @@
+/** Generic Redacted value operations, independent of application contracts. */
+export declare const redactedTransportType: {
+    readonly kind: "redacted";
+    readonly matchesValue: (value: unknown) => boolean;
+} & {
+    readonly getValue: (value: unknown) => unknown;
+    readonly getLabel: (value: unknown) => string | undefined;
+    readonly make: (value: unknown, label: string | undefined) => unknown;
+};

package/dist/universal/value-transport.d.ts

@@ -0,0 +1,117 @@
+import { Result } from "effect";
+export type JsonValue = null | boolean | number | string | ReadonlyArray<JsonValue> | {
+    readonly [key: string]: JsonValue;
+};
+export type PlatformTransportMarkKind = "date" | "bigint" | "number" | "undefined" | "map" | "set" | "url" | "url-search-params" | "regexp";
+export type EffectTransportMarkKind = "option" | "redacted" | "chunk" | "duration" | "big-decimal" | "date-time-utc" | "date-time-zoned" | "hash-map" | "hash-set";
+export type MarkKind = PlatformTransportMarkKind | EffectTransportMarkKind;
+export declare const TRANSPORT_MARK_KINDS: ReadonlySet<MarkKind>;
+export declare const EFFECT_TRANSPORT_TYPES: readonly [{
+    readonly name: "option";
+    readonly representationId: "effect/schema/Option";
+}, {
+    readonly name: "redacted";
+    readonly representationId: "effect/schema/Redacted";
+}, {
+    readonly name: "chunk";
+    readonly representationId: "effect/schema/Chunk";
+}, {
+    readonly name: "duration";
+    readonly representationId: "effect/schema/Duration";
+}, {
+    readonly name: "big-decimal";
+    readonly representationId: "effect/schema/BigDecimal";
+}, {
+    readonly name: "date-time-utc";
+    readonly representationId: "effect/schema/DateTimeUtc";
+}, {
+    readonly name: "date-time-zoned";
+    readonly representationId: "effect/schema/DateTimeZoned";
+}, {
+    readonly name: "hash-map";
+    readonly representationId: "effect/schema/HashMap";
+}, {
+    readonly name: "hash-set";
+    readonly representationId: "effect/schema/HashSet";
+}];
+type ParsedEffectValue = {
+    readonly _tag: "None";
+} | {
+    readonly _tag: "Some";
+    readonly value: unknown;
+};
+type TransportTypeEntryBase<Kind extends EffectTransportMarkKind> = {
+    readonly kind: Kind;
+    readonly matchesValue: (value: unknown) => boolean;
+};
+/** One Effect data type's runtime operations, supplied by the server or generated client module. */
+export type TransportTypeEntry = (TransportTypeEntryBase<"option"> & {
+    readonly matchesNone: (value: unknown) => boolean;
+    readonly getValue: (value: unknown) => unknown;
+    readonly none: () => unknown;
+    readonly some: (value: unknown) => unknown;
+}) | (TransportTypeEntryBase<"redacted"> & {
+    readonly getValue: (value: unknown) => unknown;
+    readonly getLabel: (value: unknown) => string | undefined;
+    readonly make: (value: unknown, label: string | undefined) => unknown;
+}) | (TransportTypeEntryBase<"chunk"> & {
+    readonly getValues: (value: unknown) => ReadonlyArray<unknown>;
+    readonly fromValues: (values: ReadonlyArray<unknown>) => unknown;
+}) | (TransportTypeEntryBase<"duration"> & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => ParsedEffectValue;
+}) | (TransportTypeEntryBase<"big-decimal"> & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => ParsedEffectValue;
+}) | (TransportTypeEntryBase<"date-time-utc"> & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => ParsedEffectValue;
+}) | (TransportTypeEntryBase<"date-time-zoned"> & {
+    readonly format: (value: unknown) => string;
+    readonly parse: (value: string) => ParsedEffectValue;
+}) | (TransportTypeEntryBase<"hash-map"> & {
+    readonly getEntries: (value: unknown) => ReadonlyArray<readonly [unknown, unknown]>;
+    readonly fromEntries: (entries: ReadonlyArray<readonly [unknown, unknown]>) => unknown;
+}) | (TransportTypeEntryBase<"hash-set"> & {
+    readonly getValues: (value: unknown) => ReadonlyArray<unknown>;
+    readonly fromValues: (values: ReadonlyArray<unknown>) => unknown;
+});
+/** One member of the vocabulary and where it sits in the JSON, as a path of keys and indexes from the root. */
+export type ValueMark = {
+    readonly path: ReadonlyArray<string | number>;
+    readonly kind: MarkKind;
+};
+/** A value on the wire: its JSON form and the marks that restore the vocabulary's members. */
+export type TransportedValue = {
+    readonly json: JsonValue;
+    readonly marks: ReadonlyArray<ValueMark>;
+};
+export type TransportEncodeError = {
+    readonly _tag: "UntransportableValue";
+    readonly path: ReadonlyArray<string | number>;
+    readonly reason: string;
+};
+export type TransportDecodeError = {
+    readonly _tag: "InvalidTransportMark";
+    readonly path: ReadonlyArray<string | number>;
+    readonly reason: string;
+};
+export declare function encodeTransportedValue(input: {
+    readonly value: unknown;
+    readonly typeEntries: ReadonlyArray<TransportTypeEntry>;
+}): Result.Result<TransportedValue, TransportEncodeError>;
+/** The reader's JSON came from a parser, so its type is only `unknown` here; the marks are what the reader checks. */
+export declare function decodeTransportedValue(input: {
+    readonly transported: {
+        readonly json: unknown;
+        readonly marks: ReadonlyArray<ValueMark>;
+    };
+    readonly typeEntries: ReadonlyArray<TransportTypeEntry>;
+}): Result.Result<unknown, TransportDecodeError>;
+/** Restores one Effect data type through the boundary-specific adapter list. */
+export declare function restoreEffectTransportType(input: {
+    readonly kind: EffectTransportMarkKind;
+    readonly value: unknown;
+    readonly typeEntries: ReadonlyArray<TransportTypeEntry>;
+}): Result.Result<unknown, TransportDecodeError>;
+export {};