@nxtedition/types 1.0.0

package/dist/domains/template.d.ts

@@ -0,0 +1,23 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+export interface TemplateDomainRecords {
+    ":template": TemplateRecord;
+}
+export interface TemplateRecord {
+    mixin?: string[];
+    properties?: Record<string, TemplateProperty>;
+}
+export declare const isTemplateRecord: (input: unknown) => input is TemplateRecord;
+export declare const assertTemplateRecord: (input: unknown) => TemplateRecord;
+export declare const randomTemplateRecord: () => TemplateRecord;
+export declare const assertGuardTemplateRecord: __AssertionGuard<TemplateRecord>;
+export declare const stringifyTemplateRecord: (input: TemplateRecord) => string;
+export declare const assertStringifyTemplateRecord: (input: unknown) => string;
+export interface TemplateProperty {
+    path?: string;
+}
+export declare const isTemplateProperty: (input: unknown) => input is TemplateProperty;
+export declare const assertTemplateProperty: (input: unknown) => TemplateProperty;
+export declare const randomTemplateProperty: () => TemplateProperty;
+export declare const assertGuardTemplateProperty: __AssertionGuard<TemplateProperty>;
+export declare const stringifyTemplateProperty: (input: TemplateProperty) => string;
+export declare const assertStringifyTemplateProperty: (input: unknown) => string;

package/dist/domains/template.js

@@ -0,0 +1,372 @@
+import __typia from "typia";
+export const isTemplateRecord = input => {
+    const $io0 = input => (undefined === input.mixin || Array.isArray(input.mixin) && input.mixin.every(elem => "string" === typeof elem)) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && $io1(input.properties));
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
+    });
+    const $io2 = input => undefined === input.path || "string" === typeof input.path;
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertTemplateRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.mixin || Array.isArray(input.mixin) && input.mixin.every(elem => "string" === typeof elem)) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && $io1(input.properties));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
+        });
+        const $io2 = input => undefined === input.path || "string" === typeof input.path;
+        return "object" === typeof input && null !== input && false === Array.isArray(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) => (undefined === input.mixin || (Array.isArray(input.mixin) || $guard(_exceptionable, {
+                path: _path + ".mixin",
+                expected: "(Array<string> | undefined)",
+                value: input.mixin
+            }, errorFactory)) && input.mixin.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".mixin[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".mixin",
+                expected: "(Array<string> | undefined)",
+                value: input.mixin
+            }, errorFactory)) && (undefined === input.properties || ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) || $guard(_exceptionable, {
+                path: _path + ".properties",
+                expected: "(Record<string, TemplateProperty> | undefined)",
+                value: input.properties
+            }, errorFactory)) && $ao1(input.properties, _path + ".properties", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".properties",
+                expected: "(Record<string, TemplateProperty> | undefined)",
+                value: input.properties
+            }, errorFactory));
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value && false === Array.isArray(value) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "TemplateProperty",
+                    value: value
+                }, errorFactory)) && $ao2(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "TemplateProperty",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao2 = (input, _path, _exceptionable = true) => undefined === input.path || "string" === typeof input.path || $guard(_exceptionable, {
+                path: _path + ".path",
+                expected: "(string | undefined)",
+                value: input.path
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomTemplateRecord = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        mixin: $pick([
+            () => undefined,
+            () => (generator?.array ?? $generator.array)(() => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)())
+        ])(),
+        properties: $pick([
+            () => undefined,
+            () => $ro1(_recursive, _recursive ? 1 + _depth : _depth)
+        ])()
+    });
+    const $ro1 = (_recursive = false, _depth = 0) => {
+        const output = {};
+        (generator?.array ?? $generator.array)(() => output[(generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()] = $ro2(_recursive, _recursive ? 1 + _depth : _depth), (generator?.integer ?? $generator.integer)(0, 3));
+        return output;
+    };
+    const $ro2 = (_recursive = false, _depth = 0) => ({
+        path: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardTemplateRecord = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.mixin || Array.isArray(input.mixin) && input.mixin.every(elem => "string" === typeof elem)) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && $io1(input.properties));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
+        });
+        const $io2 = input => undefined === input.path || "string" === typeof input.path;
+        return "object" === typeof input && null !== input && false === Array.isArray(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) => (undefined === input.mixin || (Array.isArray(input.mixin) || $guard(_exceptionable, {
+                path: _path + ".mixin",
+                expected: "(Array<string> | undefined)",
+                value: input.mixin
+            }, errorFactory)) && input.mixin.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".mixin[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".mixin",
+                expected: "(Array<string> | undefined)",
+                value: input.mixin
+            }, errorFactory)) && (undefined === input.properties || ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) || $guard(_exceptionable, {
+                path: _path + ".properties",
+                expected: "(Record<string, TemplateProperty> | undefined)",
+                value: input.properties
+            }, errorFactory)) && $ao1(input.properties, _path + ".properties", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".properties",
+                expected: "(Record<string, TemplateProperty> | undefined)",
+                value: input.properties
+            }, errorFactory));
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value && false === Array.isArray(value) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "TemplateProperty",
+                    value: value
+                }, errorFactory)) && $ao2(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "TemplateProperty",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao2 = (input, _path, _exceptionable = true) => undefined === input.path || "string" === typeof input.path || $guard(_exceptionable, {
+                path: _path + ".path",
+                expected: "(string | undefined)",
+                value: input.path
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateRecord",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyTemplateRecord = input => {
+    const $io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
+    });
+    const $io2 = input => undefined === input.path || "string" === typeof input.path;
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.mixin ? "" : `"mixin":${undefined !== input.mixin ? `[${input.mixin.map(elem => $string(elem)).join(",")}]` : undefined},`}${undefined === input.properties ? "" : `"properties":${undefined !== input.properties ? $so1(input.properties) : undefined}`}`)}}`;
+    const $so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$so2(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    const $so2 = input => `{${$tail(`${undefined === input.path ? "" : `"path":${undefined !== input.path ? $string(input.path) : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyTemplateRecord = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => (undefined === input.mixin || Array.isArray(input.mixin) && input.mixin.every(elem => "string" === typeof elem)) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && $io1(input.properties));
+        const $io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
+        });
+        const $io2 = input => undefined === input.path || "string" === typeof input.path;
+        return "object" === typeof input && null !== input && false === Array.isArray(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) => (undefined === input.mixin || (Array.isArray(input.mixin) || $guard(_exceptionable, {
+                path: _path + ".mixin",
+                expected: "(Array<string> | undefined)",
+                value: input.mixin
+            }, errorFactory)) && input.mixin.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                path: _path + ".mixin[" + _index1 + "]",
+                expected: "string",
+                value: elem
+            }, errorFactory)) || $guard(_exceptionable, {
+                path: _path + ".mixin",
+                expected: "(Array<string> | undefined)",
+                value: input.mixin
+            }, errorFactory)) && (undefined === input.properties || ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) || $guard(_exceptionable, {
+                path: _path + ".properties",
+                expected: "(Record<string, TemplateProperty> | undefined)",
+                value: input.properties
+            }, errorFactory)) && $ao1(input.properties, _path + ".properties", true && _exceptionable) || $guard(_exceptionable, {
+                path: _path + ".properties",
+                expected: "(Record<string, TemplateProperty> | undefined)",
+                value: input.properties
+            }, errorFactory));
+            const $ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value && false === Array.isArray(value) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "TemplateProperty",
+                    value: value
+                }, errorFactory)) && $ao2(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                    path: _path + $join(key),
+                    expected: "TemplateProperty",
+                    value: value
+                }, errorFactory);
+            });
+            const $ao2 = (input, _path, _exceptionable = true) => undefined === input.path || "string" === typeof input.path || $guard(_exceptionable, {
+                path: _path + ".path",
+                expected: "(string | undefined)",
+                value: input.path
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateRecord",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateRecord",
+                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 "object" === typeof value && null !== value && false === Array.isArray(value) && $io2(value);
+    });
+    const $io2 = input => undefined === input.path || "string" === typeof input.path;
+    const $string = __typia.json.createAssertStringify.string;
+    const $tail = __typia.json.createAssertStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.mixin ? "" : `"mixin":${undefined !== input.mixin ? `[${input.mixin.map(elem => $string(elem)).join(",")}]` : undefined},`}${undefined === input.properties ? "" : `"properties":${undefined !== input.properties ? $so1(input.properties) : undefined}`}`)}}`;
+    const $so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
+        return ""; return `${JSON.stringify(key)}:${$so2(value)}`; }).filter(str => "" !== str).join(",")}}`;
+    const $so2 = input => `{${$tail(`${undefined === input.path ? "" : `"path":${undefined !== input.path ? $string(input.path) : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };
+export const isTemplateProperty = input => {
+    const $io0 = input => undefined === input.path || "string" === typeof input.path;
+    return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+};
+export const assertTemplateProperty = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.path || "string" === typeof input.path;
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssert.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.path || "string" === typeof input.path || $guard(_exceptionable, {
+                path: _path + ".path",
+                expected: "(string | undefined)",
+                value: input.path
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateProperty",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateProperty",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+};
+export const randomTemplateProperty = generator => {
+    const $generator = __typia.createRandom.generator;
+    const $pick = __typia.createRandom.pick;
+    const $ro0 = (_recursive = false, _depth = 0) => ({
+        path: $pick([
+            () => undefined,
+            () => (generator?.customs ?? $generator.customs)?.string?.([]) ?? (generator?.string ?? $generator.string)()
+        ])()
+    });
+    return $ro0();
+};
+export const assertGuardTemplateProperty = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.path || "string" === typeof input.path;
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.createAssertGuard.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.path || "string" === typeof input.path || $guard(_exceptionable, {
+                path: _path + ".path",
+                expected: "(string | undefined)",
+                value: input.path
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateProperty",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateProperty",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+};
+export const stringifyTemplateProperty = input => {
+    const $string = __typia.json.createStringify.string;
+    const $tail = __typia.json.createStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.path ? "" : `"path":${undefined !== input.path ? $string(input.path) : undefined}`}`)}}`;
+    return $so0(input);
+};
+export const assertStringifyTemplateProperty = (input, errorFactory) => { const assert = (input, errorFactory) => {
+    const __is = input => {
+        const $io0 = input => undefined === input.path || "string" === typeof input.path;
+        return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+    };
+    if (false === __is(input))
+        ((input, _path, _exceptionable = true) => {
+            const $guard = __typia.json.createAssertStringify.guard;
+            const $ao0 = (input, _path, _exceptionable = true) => undefined === input.path || "string" === typeof input.path || $guard(_exceptionable, {
+                path: _path + ".path",
+                expected: "(string | undefined)",
+                value: input.path
+            }, errorFactory);
+            return ("object" === typeof input && null !== input && false === Array.isArray(input) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateProperty",
+                value: input
+            }, errorFactory)) && $ao0(input, _path + "", true) || $guard(true, {
+                path: _path + "",
+                expected: "TemplateProperty",
+                value: input
+            }, errorFactory);
+        })(input, "$input", true);
+    return input;
+}; const stringify = input => {
+    const $string = __typia.json.createAssertStringify.string;
+    const $tail = __typia.json.createAssertStringify.tail;
+    const $so0 = input => `{${$tail(`${undefined === input.path ? "" : `"path":${undefined !== input.path ? $string(input.path) : undefined}`}`)}}`;
+    return $so0(input);
+}; return stringify(assert(input, errorFactory)); };

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import type { DomainRecords } from './domains/index.js';
+export * from './domains/index.js';
+export * from './common/index.js';
+export type Records = {
+    [Property in keyof DomainRecords as `${string}${Property}`]: DomainRecords[Property];
+} & {
+    "media.subtitles?": {
+        languages: Record<string, string>;
+    };
+    "media.transcribe?": {
+        engines: Record<string, string>;
+        languages: Record<string, string>;
+        translate?: {
+            languages: Record<string, string>;
+        };
+    };
+    "hub-transcribe:render-profile": {
+        format: string;
+        transcribe: {
+            engine: string;
+        };
+        pick: string[];
+    };
+};

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './domains/index.js';
+export * from './common/index.js';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@nxtedition/types",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "prepare": "ts-patch install && typia patch",
+    "prebuild": "rimraf dist",
+    "build": "tspc",
+    "lint": "npx eslint .",
+    "prepublishOnly": "yarn lint && yarn build && yarn test",
+    "test": "node --test ./__test__/*.test.mjs",
+    "benchmark": "node ./__test__/benchmark.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./common/*": "./dist/common/*",
+    "./domains/*": "./dist/domains/*"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "type-fest": "^4.15.0",
+    "typia": "^6.0.4"
+  },
+  "devDependencies": {
+    "fast-json-stringify": "^5.16.0",
+    "mitata": "^0.1.11",
+    "rimraf": "^5.0.7",
+    "ts-node": "^10.9.2",
+    "ts-patch": "^3.1.2",
+    "typescript": "^5.4.5"
+  }
+}