@valbuild/core 0.12.0

package/dist/declarations/src/selector/string.d.ts

@@ -0,0 +1,2 @@
+import { Selector as PrimitiveSelector } from "./primitive";
+export type Selector<T extends string> = PrimitiveSelector<T>;

package/dist/declarations/src/source/file.d.ts

@@ -0,0 +1,23 @@
+import { VAL_EXTENSION } from ".";
+import { JsonPrimitive } from "../Json";
+export declare const FILE_REF_PROP: "_ref";
+/**
+ * A file source represents the path to a (local) file.
+ *
+ * It will be resolved into a Asset object.
+ *
+ */
+export type FileSource<Metadata extends {
+    readonly [key: string]: JsonPrimitive;
+} | undefined = {
+    readonly [key: string]: JsonPrimitive;
+} | undefined> = {
+    readonly [FILE_REF_PROP]: string;
+    readonly [VAL_EXTENSION]: "file";
+    readonly metadata?: Metadata;
+};
+export declare function file<Metadata extends {
+    readonly [key: string]: JsonPrimitive;
+}>(ref: string, metadata: Metadata): FileSource<Metadata>;
+export declare function file(ref: string, metadata?: undefined): FileSource<undefined>;
+export declare function isFile(obj: unknown): obj is FileSource;

package/dist/declarations/src/source/i18n.d.ts

@@ -0,0 +1,29 @@
+import { F } from "ts-toolbelt";
+import { SourcePrimitive, VAL_EXTENSION } from ".";
+import { FileSource } from "./file";
+/**
+ * I18n sources cannot have nested remote sources.
+ */
+export type I18nCompatibleSource = SourcePrimitive | I18nObject | I18nArray | FileSource;
+export type I18nObject = {
+    [key in string]: I18nCompatibleSource;
+};
+export type I18nArray = readonly I18nCompatibleSource[];
+/**
+ * An i18n source is a map of locales to sources.
+ *
+ * Its selector will default to the underlying source. It is possible to call `.all` on i18n sources, which returns an object with all the locales
+ *
+ */
+export type I18nSource<Locales extends readonly string[], T extends I18nCompatibleSource> = {
+    readonly [locale in Locales[number]]: T;
+} & {
+    readonly [VAL_EXTENSION]: "i18n";
+};
+export type I18n<Locales extends readonly string[]> = <Src extends I18nCompatibleSource>(source: {
+    [locale in Locales[number]]: Src;
+}) => I18nSource<Locales, Src>;
+export declare function i18n<Locales extends readonly string[]>(locales: F.Narrow<Locales>): <Src extends I18nCompatibleSource>(source: {
+    [locale in Locales[number]]: Src;
+}) => I18nSource<Locales, Src>;
+export declare function isI18n(obj: unknown): obj is I18nSource<string[], I18nCompatibleSource>;

package/dist/declarations/src/source/index.d.ts

@@ -0,0 +1,33 @@
+import { FileSource } from "./file";
+import { I18nSource, I18nCompatibleSource } from "./i18n";
+import { RemoteSource, RemoteCompatibleSource } from "./remote";
+export type Source = SourcePrimitive | SourceObject | SourceArray | I18nSource<string[], I18nCompatibleSource> | RemoteSource<RemoteCompatibleSource> | FileSource;
+export type SourceObject = {
+    [key in string]: Source;
+} & {
+    fold?: never;
+    andThen?: never;
+    _ref?: never;
+    _type?: never;
+    val?: never;
+    valPath?: never;
+};
+export type SourceArray = readonly Source[];
+export type SourcePrimitive = string | number | boolean | null;
+export declare const VAL_EXTENSION: "_type";
+export declare function getValExtension(source: Source): false | "" | 0 | "file" | "i18n" | "remote" | null | undefined;
+/**
+ * A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.
+ *
+ * An example where this is useful is remote types, where the type of the remote source is known at compile time,
+ * but the value is not there before it is fetched.
+ *
+ * @example
+ * type Example<T> = string & PhantomType<T>;
+ *
+ **/
+declare const PhantomType: unique symbol;
+export type PhantomType<T> = {
+    [PhantomType]: T;
+};
+export {};

package/dist/declarations/src/source/remote.d.ts

@@ -0,0 +1,29 @@
+import { SourcePrimitive, VAL_EXTENSION, PhantomType } from ".";
+import { RichText } from "../schema/richtext";
+import { FileSource } from "./file";
+import { I18nCompatibleSource, I18nSource } from "./i18n";
+/**
+ * Remote sources cannot include other remote sources.
+ */
+export type RemoteCompatibleSource = SourcePrimitive | RemoteObject | RemoteArray | RichText | FileSource | I18nSource<string[], I18nCompatibleSource>;
+export type RemoteObject = {
+    [key in string]: RemoteCompatibleSource;
+};
+export type RemoteArray = readonly RemoteCompatibleSource[];
+export declare const REMOTE_REF_PROP: "_ref";
+declare const brand: unique symbol;
+export type RemoteRef = string & {
+    readonly [brand]: "RemoteRef";
+};
+/**
+ * A remote source is a hash that represents a remote object.
+ *
+ * It will be resolved into a ValRemote object.
+ */
+export type RemoteSource<Src extends RemoteCompatibleSource> = {
+    readonly [REMOTE_REF_PROP]: RemoteRef;
+    readonly [VAL_EXTENSION]: "remote";
+} & PhantomType<Src>;
+export declare function remote<Src extends RemoteCompatibleSource>(ref: string): RemoteSource<Src>;
+export declare function isRemote(obj: unknown): obj is RemoteSource<RemoteCompatibleSource>;
+export {};

package/dist/declarations/src/val/array.d.ts

@@ -0,0 +1,9 @@
+import { SourcePath, Val as UnknownVal } from ".";
+import { JsonArray } from "../Json";
+import { Path } from "../selector";
+export type Val<T extends JsonArray> = {
+    readonly [key in keyof T]: UnknownVal<T[key]>;
+} & {
+    readonly [Path]: SourcePath | undefined;
+    readonly val: T;
+};

package/dist/declarations/src/val/index.d.ts

@@ -0,0 +1,53 @@
+import { Source, SourceArray, SourceObject } from "../source";
+import { Val as ObjectVal } from "./object";
+import { Val as ArrayVal } from "./array";
+import { Val as PrimitiveVal } from "./primitive";
+import { Json, JsonArray, JsonObject, JsonPrimitive } from "../Json";
+import { Path, Selector } from "../selector";
+import { I18nSource } from "../source/i18n";
+import { RemoteSource } from "../source/remote";
+import { FileSource } from "../source/file";
+export type SerializedVal = {
+    val: SerializedVal | Json;
+    valPath: SourcePath | undefined;
+};
+export declare function isSerializedVal(val: unknown): val is SerializedVal;
+export type JsonOfSource<T extends Source> = Json extends T ? Json : T extends I18nSource<readonly string[], infer U> ? JsonOfSource<U> : T extends RemoteSource<infer U> ? JsonOfSource<U> : T extends FileSource ? {
+    url: string;
+} : T extends SourceObject ? {
+    [key in keyof T]: JsonOfSource<T[key]>;
+} : T extends SourceArray ? JsonOfSource<T[number]>[] : T extends JsonPrimitive ? T : never;
+export type Val<T extends Json> = Json extends T ? {
+    readonly [Path]: SourcePath | undefined;
+    readonly val: Source;
+} : T extends JsonObject ? ObjectVal<T> : T extends JsonArray ? ArrayVal<T> : T extends JsonPrimitive ? PrimitiveVal<T> : never;
+declare const brand: unique symbol;
+/**
+ * The path of the source value.
+ *
+ * @example
+ * '/app/blogs.0.text' // the text property of the first element of the /app/blogs module
+ */
+export type SourcePath = string & {
+    [brand]: "SourcePath";
+};
+/**
+ * The path inside the module.
+ *
+ * @example
+ * '0."text"' // the text property of the first element of the module
+ */
+export type ModulePath = string & {
+    [brand]: "ModulePath";
+};
+/**
+ * The id of the module.
+ *
+ * @example
+ * '/app/blogs' // the /app/blogs module
+ */
+export type ModuleId = string & {
+    [brand]: "ModuleId";
+};
+export declare function getValPath(valOrSelector: Val<Json> | Selector<Source>): SourcePath | undefined;
+export {};

package/dist/declarations/src/val/object.d.ts

@@ -0,0 +1,9 @@
+import { SourcePath, Val as UnknownVal } from ".";
+import { JsonObject } from "../Json";
+import { Path } from "../selector";
+export type Val<T extends JsonObject> = Omit<{
+    readonly [key in keyof T]: UnknownVal<T[key]>;
+}, "valPath" | "val"> & {
+    readonly [Path]: SourcePath | undefined;
+    readonly val: T;
+};

package/dist/declarations/src/val/primitive.d.ts

@@ -0,0 +1,7 @@
+import { SourcePath } from ".";
+import { JsonPrimitive } from "../Json";
+import { Path } from "../selector";
+export type Val<T extends JsonPrimitive> = {
+    [Path]: SourcePath | undefined;
+    val: T;
+};