@nxtedition/types 23.0.31 → 23.0.33

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export declare const randomDomains: () => Domains;
 export declare const assertGuardDomains: __AssertionGuard<Domains>;
 export declare const stringifyDomains: (input: Domains) => string;
 export declare const assertStringifyDomains: (input: unknown) => string;
+export * from './nxtpression.js';
 export type Records = {
     [Property in Domains as `${string}${Property}`]: DomainRecords[Property];
 } & {
@@ -21,8 +22,13 @@ export type Records = {
 } & {
     [Property in keyof DesignDomainRecords as `${string}${Property}${string}`]: DesignDomainRecords[Property];
 } & {
+    "media.subtitles": {
+        languages?: Record<string, string>;
+        fontFaces?: SubtitleFontFace[];
+    };
     "media.subtitles?": {
-        languages: Record<string, string>;
+        languages?: Record<string, string>;
+        fontFaces?: SubtitleFontFace[];
     };
     "media.transcribe?": {
         engines: Record<string, string>;
@@ -67,3 +73,9 @@ export type Records = {
 interface DomainRows {
     rows: string[];
 }
+interface SubtitleFontFace {
+    family: string;
+    asset?: string;
+    weight?: "normal" | "bold";
+    style?: "normal" | "italic";
+}

package/dist/index.js

@@ -180,3 +180,4 @@ export const assertStringifyDomains = (input, errorFactory) => { const assert =
         });
     })();
 }; return stringify(assert(input, errorFactory)); };
+export * from './nxtpression.js';

package/dist/nxtpression.d.ts

@@ -0,0 +1,110 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+import type { DomainRecords } from './domains/index.js';
+import type { Records } from './index.js';
+import type { Observable } from 'rxjs';
+type Paths<Data> = keyof Data & string;
+type Get<Data, Path extends string> = Path extends keyof Data ? Data[Path] : unknown;
+type RecordStateNumber = 0 | 1 | 2 | 3 | 4;
+type RecordStateString = "VOID" | "CLIENT" | "SERVER" | "STALE" | "PROVIDER";
+type RecordState = RecordStateNumber | RecordStateString;
+type _UnaryFunction<T, U> = (arg: T extends null ? never : T) => U;
+export interface Underscore {
+    <T>(input: T): T;
+    <T, U>(input: T, fn1: _UnaryFunction<T, U>): U;
+    <T, U, V>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>): V;
+    <T, U, V, W>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>): W;
+    <T, U, V, W, X>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>, fn4: _UnaryFunction<W, X>): X;
+    <T, U, V, W, X, Y>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>, fn4: _UnaryFunction<W, X>, fn5: _UnaryFunction<X, Y>): Y;
+    <T, U, V, W, X, Y, Z>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>, fn4: _UnaryFunction<W, X>, fn5: _UnaryFunction<X, Y>, fn6: _UnaryFunction<Y, Z>): Z;
+    /**
+     * Creates a function which returns the input assetId, only if the asset is of the provided type.
+     * @param type Asset type to filter on, e.g. "general" or "media"
+     */
+    asset: (type: string, state?: number, suspend?: boolean) => (id: string) => string | null;
+    /**
+     * @deprecated
+     */
+    ds: <Postfix extends keyof DomainRecords, Data extends DomainRecords[Postfix] = DomainRecords[Postfix]>(postfix: Postfix, state?: number, suspend?: boolean) => (assetId: string) => Data;
+    /**
+     * Get a deepstream record
+     *
+     * Takes a postfix (typically a :domain) and optionally record path and/or
+     * desired state. Returns a function which takes a prefix (typically an asset
+     * ID).
+     *
+     * @example
+     * _.get(':contact') // (assetId: string) => ContactRecord
+     *
+     * @example
+     * _.get(':contact', null, 'server') // (assetId: string) => ContactRecord
+     *
+     * @example
+     * _.get(':contact', 'firstName') // (assetId: string) => string | undefined
+     *
+     * @example
+     * _.get(':contact', 'firstName', 'server') // (assetId: string) => string | undefined
+     */
+    get<Postfix extends keyof DomainRecords, Data extends DomainRecords[Postfix] = DomainRecords[Postfix], Path extends Paths<Data> | string | null | undefined = Paths<Data>>(postfix: Postfix, path: Path, state?: RecordState, suspend?: boolean): (assetId: string) => Path extends undefined | null ? Partial<Data> : Path extends Paths<Data> ? Get<Data, Path> | undefined : unknown;
+    get<Postfix extends keyof DomainRecords, Data extends DomainRecords[Postfix] = DomainRecords[Postfix]>(postfix: Postfix): (assetId: string) => Partial<Data>;
+    timer<V>(dueTime: number): (dueValue?: V) => V;
+    fetch(options?: RequestInit, suspend?: boolean): (resource: string) => NxtpressionFetch;
+}
+export interface NxtpressionNxt {
+    /**
+     * HTTP fetch
+     */
+    fetch(url: string, options?: RequestInit, suspend?: boolean): NxtpressionFetch;
+    observe<Value>(observable: Observable<Value>, suspend?: boolean): Value;
+    then<Value>(promise: Promise<Value>, suspend?: boolean): Value;
+    suspend(): void;
+    /**
+     * Creates a function which returns the input assetId, only if the asset is of the provided type.
+     * @param type Asset type to filter on, e.g. "general" or "media"
+     */
+    asset: (assetId: string, type: string, state?: number, suspend?: boolean) => (assetId: string) => string | null;
+    /**
+     * @deprecated
+     */
+    ds<Name extends keyof Records, Data extends Records[Name] & string>(name: Name, state?: RecordState, suspend?: boolean): Data;
+    /**
+     * Get a record.
+     */
+    get<Name extends keyof Records, Data extends Records[Name] = Records[Name], Path extends Paths<Data> | undefined | null = undefined>(name: Name, path?: Path, state?: RecordState, suspend?: boolean): Path extends undefined | null ? Data : Path extends Paths<Data> ? Get<Data, Path> : unknown;
+    get<Name extends keyof Records, Data extends Records[Name] = Records[Name]>(name: Name): Partial<Data>;
+    /**
+     * TODO: what is this doing?
+     */
+    wrap: <V>(value: V, suspend?: boolean) => unknown;
+    timer<V>(dueTime: number, dueValue: V, suspend?: boolean): V;
+    hash(value: unknown): string;
+}
+export declare const isNxtpressionNxt: (input: unknown) => input is NxtpressionNxt;
+export declare const assertNxtpressionNxt: (input: unknown) => NxtpressionNxt;
+export declare const randomNxtpressionNxt: () => {
+    fetch: never;
+    observe: never;
+    then: never;
+    suspend: never;
+    asset: never;
+    ds: never;
+    get: never;
+    wrap: never;
+    timer: never;
+    hash: never;
+};
+export declare const assertGuardNxtpressionNxt: __AssertionGuard<NxtpressionNxt>;
+export declare const stringifyNxtpressionNxt: (input: NxtpressionNxt) => string;
+export declare const assertStringifyNxtpressionNxt: (input: unknown) => string;
+export interface NxtpressionFetch {
+    body: string | null;
+    status: number | null;
+    headers: Record<string, string>;
+    err: any;
+}
+export declare const isNxtpressionFetch: (input: unknown) => input is NxtpressionFetch;
+export declare const assertNxtpressionFetch: (input: unknown) => NxtpressionFetch;
+export declare const randomNxtpressionFetch: () => NxtpressionFetch;
+export declare const assertGuardNxtpressionFetch: __AssertionGuard<NxtpressionFetch>;
+export declare const stringifyNxtpressionFetch: (input: NxtpressionFetch) => string;
+export declare const assertStringifyNxtpressionFetch: (input: unknown) => string;
+export {};

package/dist/nxtpression.js

@@ -0,0 +1,323 @@
+import __typia from "typia";
+export const isNxtpressionNxt = input => {
+    const $io0 = input => true && true;
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertNxtpressionNxt = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => true && true;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => (true || $guard(_exceptionable, {
+                path: _path + ".asset",
+                expected: "unknown",
+                value: input.asset
+            }, errorFactory)) && (true || $guard(_exceptionable, {
+                path: _path + ".wrap",
+                expected: "unknown",
+                value: input.wrap
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionNxt",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionNxt",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomNxtpressionNxt = generator => {
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        asset: undefined,
+        wrap: undefined
+    });
+    return $ro0();
+};
+export const assertGuardNxtpressionNxt = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => true && true;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => (true || $guard(_exceptionable, {
+                path: _path + ".asset",
+                expected: "unknown",
+                value: input.asset
+            }, errorFactory)) && (true || $guard(_exceptionable, {
+                path: _path + ".wrap",
+                expected: "unknown",
+                value: input.wrap
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionNxt",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionNxt",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyNxtpressionNxt = input => {
+    const $so0 = input => "{}";
+    return $so0(input);
+};
+export const assertStringifyNxtpressionNxt = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => true && true;
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => (true || $guard(_exceptionable, {
+                path: _path + ".asset",
+                expected: "unknown",
+                value: input.asset
+            }, errorFactory)) && (true || $guard(_exceptionable, {
+                path: _path + ".wrap",
+                expected: "unknown",
+                value: input.wrap
+            }, errorFactory));
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionNxt",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionNxt",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $so0 = input => "{}";
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isNxtpressionFetch = input => {
+    const $io0 = input => (null === input.body || "string" === typeof input.body) && (null === input.status || "number" === typeof input.status) && ("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) && $io1(input.headers)) && true;
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    return "object" === typeof input && null !== input && $io0(input);
+};
+export const assertNxtpressionFetch = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (null === input.body || "string" === typeof input.body) && (null === input.status || "number" === typeof input.status) && ("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) && $io1(input.headers)) && true;
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $join = __typia.createAssert.join;
+            const $ao0 = (input, _path, _exceptionable = true) => (null === input.body || "string" === typeof input.body || $guard(_exceptionable, {
+                path: _path + ".body",
+                expected: "(null | string)",
+                value: input.body
+            }, errorFactory)) && (null === input.status || "number" === typeof input.status || $guard(_exceptionable, {
+                path: _path + ".status",
+                expected: "(null | number)",
+                value: input.status
+            }, errorFactory)) && (("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) || $guard(_exceptionable, {
+                path: _path + ".headers",
+                expected: "Record<string, string>",
+                value: input.headers
+            }, errorFactory)) && $ao1(input.headers, _path + ".headers", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".headers",
+                expected: "Record<string, string>",
+                value: input.headers
+            }, errorFactory)) && true;
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionFetch",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionFetch",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomNxtpressionFetch = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        body: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])(),
+        status: $pick([
+            () => null,
+            () => (generator?.customs ?? $generator.customs)?.number?.([]) ?? (generator?.number ?? $generator.number)(0, 100)
+        ])(),
+        headers: $ro1(_recursive, _recursive ? 1 + _depth : _depth),
+        err: "any type used..."
+    });
+    const $ro1 = (_recursive = false, _depth = 0) => {
+        const output = {};
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()] = (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)(), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    return $ro0();
+};
+export const assertGuardNxtpressionFetch = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (null === input.body || "string" === typeof input.body) && (null === input.status || "number" === typeof input.status) && ("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) && $io1(input.headers)) && true;
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $join = __typia.createAssertGuard.join;
+            const $ao0 = (input, _path, _exceptionable = true) => (null === input.body || "string" === typeof input.body || $guard(_exceptionable, {
+                path: _path + ".body",
+                expected: "(null | string)",
+                value: input.body
+            }, errorFactory)) && (null === input.status || "number" === typeof input.status || $guard(_exceptionable, {
+                path: _path + ".status",
+                expected: "(null | number)",
+                value: input.status
+            }, errorFactory)) && (("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) || $guard(_exceptionable, {
+                path: _path + ".headers",
+                expected: "Record<string, string>",
+                value: input.headers
+            }, errorFactory)) && $ao1(input.headers, _path + ".headers", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".headers",
+                expected: "Record<string, string>",
+                value: input.headers
+            }, errorFactory)) && true;
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionFetch",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionFetch",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyNxtpressionFetch = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    const $string = __typia.json.createStringify.string;
+    const $so0 = input => `{${undefined === input.err || "function" === typeof input.err ? "" : `"err":${undefined !== input.err ? JSON.stringify(input.err) : undefined},`}"body":${null !== input.body ? $string(input.body) : "null"},"status":${null !== input.status ? input.status : "null"},"headers":${$so1(input.headers)}}`;
+    const $so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$string(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+};
+export const assertStringifyNxtpressionFetch = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (null === input.body || "string" === typeof input.body) && (null === input.status || "number" === typeof input.status && !Number.isNaN(input.status)) && ("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) && $io1(input.headers)) && true;
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value;
+        });
+        return "object" === typeof input && null !== input && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $join = __typia.json.createAssertStringify.join;
+            const $ao0 = (input, _path, _exceptionable = true) => (null === input.body || "string" === typeof input.body || $guard(_exceptionable, {
+                path: _path + ".body",
+                expected: "(null | string)",
+                value: input.body
+            }, errorFactory)) && (null === input.status || "number" === typeof input.status && !Number.isNaN(input.status) || $guard(_exceptionable, {
+                path: _path + ".status",
+                expected: "(null | number)",
+                value: input.status
+            }, errorFactory)) && (("object" === typeof input.headers && null !== input.headers && false === Array.isArray(input.headers) || $guard(_exceptionable, {
+                path: _path + ".headers",
+                expected: "Record<string, string>",
+                value: input.headers
+            }, errorFactory)) && $ao1(input.headers, _path + ".headers", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".headers",
+                expected: "Record<string, string>",
+                value: input.headers
+            }, errorFactory)) && true;
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return "string" === typeof value || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "string",
+                    value: value
+                }, errorFactory);
+            });
+            return ("object" === typeof input && null !== input || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionFetch",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "NxtpressionFetch",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    });
+    const $string = __typia.json.createAssertStringify.string;
+    const $so0 = input => `{${undefined === input.err || "function" === typeof input.err ? "" : `"err":${undefined !== input.err ? JSON.stringify(input.err) : undefined},`}"body":${null !== input.body ? $string(input.body) : "null"},"status":${null !== input.status ? input.status : "null"},"headers":${$so1(input.headers)}}`;
+    const $so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$string(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };