@nxtedition/types 1.0.0

package/README.md

@@ -0,0 +1,62 @@
+# @nxtedition/types
+
+## Description
+
+This package contains:
+
+- TypeScript types to be shared between nxtedition packages.
+- Runtime validatiors and JSON functions for those types.
+
+## Usage
+
+Import types and validators like this in TypeScript:
+
+```typescript
+import type { TemplateRecord } from '@nxtedition/types'
+import { isTemplateRecord } from '@nxtedition/types'
+```
+
+const templateRecord: TemplateRecord = {
+...
+}
+
+````
+
+And like this in JavaScript:
+
+```javascript
+import { isTemplateRecord } from '@nxtedition/types'
+
+/**
+ * @typedef { import("@nxtedition/types").TemplateRecord } TemplateRecord
+ */
+
+/** @type {TemplateRecord} */
+const templateRecord = { ... }
+````
+
+If bundle size is an issue, you can import only the parts you need like this:
+
+```typescript
+import { isTemplateRecord } from '@nxtedition/types/domains/template'
+```
+
+## Development
+
+### Generate runtime code
+
+Generally, we only manually specify types in this package. A code generator is
+used to generate the runtime validators and JSON functions. It will do so for
+all types that are exported. To run the generator, use the following command:
+
+```bash
+yarn build
+```
+
+This will build the output to the `dist` directory.
+
+### Exports
+
+We export all types up to the root of the package, so they can be imported
+directly from `@nxtedition/types`. This means that all exported types must
+be uniquely named.

package/dist/common/block.d.ts

@@ -0,0 +1,25 @@
+import { type AssertionGuard as __AssertionGuard } from "typia";
+import { tags } from 'typia';
+export interface Block {
+    fileId: string;
+    locationId: string;
+    blockId: string;
+    offset?: number & tags.Type<"uint32">;
+    position?: number & tags.Type<"uint32">;
+    size?: number & tags.Type<"uint32">;
+    hash?: string;
+    btime?: number & tags.Type<"uint32">;
+}
+export declare const isBlock: (input: unknown) => input is Block;
+export declare const assertBlock: (input: unknown) => Block;
+export declare const randomBlock: () => Block;
+export declare const assertGuardBlock: __AssertionGuard<Block>;
+export declare const stringifyBlock: (input: Block) => string;
+export declare const assertStringifyBlock: (input: unknown) => string;
+export type Blocks = Block[];
+export declare const isBlocks: (input: unknown) => input is Blocks;
+export declare const assertBlocks: (input: unknown) => Blocks;
+export declare const randomBlocks: () => Blocks;
+export declare const assertGuardBlocks: __AssertionGuard<Blocks>;
+export declare const stringifyBlocks: (input: Blocks) => string;
+export declare const assertStringifyBlocks: (input: unknown) => string;