@typedly/data 5.0.0-beta → 5.0.0

package/README.md

@@ -10,39 +10,53 @@
 ## @typedly/data
 
 <!-- npm badge -->
-[![npm version][typedly-npm-badge-svg]][typedly-npm-badge]
-[![GitHub issues][typedly-badge-issues]][typedly-issues]
-[![GitHub license][typedly-badge-license]][typedly-license]
+[![npm version][package-npm-badge-svg]][package-npm-badge]
+[![GitHub issues][package-badge-issues]][package-issues]
+[![GitHub license][package-badge-license]][package-license]
+
+<!-- GitHub badges -->
+[![GitHub issues][package-badge-issues]][package-issues]
+[![GitHub forks][package-badge-forks]][package-forks]
+[![GitHub stars][package-badge-stars]][package-stars]
+[![GitHub license][package-badge-license]][package-license]
+
+<!-- Sponsors -->
+[![GitHub Sponsors][github-badge-sponsor]][github-sponsor-link]
+[![Patreon Sponsors][patreon-badge]][patreon-link]
 
 A **TypeScript** type definitions package for [**@typescript-package/data**](https://github.com/typescript-package/data).
 
 ## Features
 
-- **Adapter**: Optional data adapter to customize managing underlying data.
+- **Adapter**: Optional data adapter to customize managing underlying data available under the [`@typedly/adaptable-data`](https://github.com/typedly/data-adapter).
+- **Configurable**: Configurable data shape available under the [`@typedly/configurable-data`](https://github.com/typedly/configurable-data).
+- **Traits**: Extended customization via traits, such as `Configurable`, `Adaptable`, `Serializable`, and `Transformable` under the [`@typedly/data-traits`](https://github.com/typedly/data-traits) package.
 - **Shape**: The default shape for data of any `T` type with conditional async.
 
 ## Table of contents
 
+- [Related packages](#related-packages)
 - [Installation](#installation)
 - [Api](#api)
-  - [Constructor](#constructor)
-    - [`AdaptableDataConstructor`](#adaptabledataconstructor)
-    - [`DataAdapterConstructor`](#dataadapterconstructor)
-    - [`DataConstructor`](#dataconstructor)
-    - [`ValueConstructor`](#valueconstructor)
-  - [Interface](#interface)
-    - [`AdaptableDataShape`](#adaptabledatashape)
-    - [`DataAdapterShape`](#dataadaptershape)
-    - [`DataShape`](#datashape)
-    - [`ValueShape`](#valueshape)
-  - [Type](#type)
-    - [`AdaptableDataConstructorInput`](#adaptabledataconstructorinput)
-    - [`AdaptableDataConstructorTuple`](#adaptabledataconstructortuple)
+  - [Configuration](#configuration)
+    - [`DataConfig`](#dataconfig)
+    - [`DataSettings`](#datasettings)
+  - [Data](#data)
     - [`AsyncReturn`](#asyncreturn)
     - [`DataConstructorInput`](#dataconstructorinput)
     - [`DataConstructorTuple`](#dataconstructortuple)
+    - [`DataConstructor`](#dataconstructor)
+    - [`DataShape`](#datashape)
+  - [Inference](#inference)
+    - [`InferAsyncOf`](#inferasyncof)
+    - [`InferAsync`](#inferasync)
+    - [`InferValue`](#infervalue)
+  - [Iterable](#iterable)
     - [`IterValue`](#itervalue)
-- [Full example usage](#full-example-usage)
+    - [`IterableElement`](#itervalue)
+  - [Value](#value)
+    - [`ValueConstructor`](#valueconstructor)
+    - [`ValueShape`](#valueshape)
 - [Contributing](#contributing)
 - [Support](#support)
 - [Code of Conduct](#code-of-conduct)
@@ -50,7 +64,17 @@ A **TypeScript** type definitions package for [**@typescript-package/data**](htt
   - [Commit](#commit)
   - [Versioning](#versioning)
 - [License](#license)
-- [Related packages](#related-packages)
+- [Packages](#packages)
+
+## Related packages
+
+- **[@typedly/adaptable-data](https://github.com/typedly/adaptable-data)**: A **TypeScript** type definitions for data adapter.
+- **[@typedly/collection](https://github.com/typedly/collection)**: A **TypeScript** type definitions package for data collections with customizable storage.
+- **[@typedly/configurable-data](https://github.com/typedly/configurable-data)**: A **TypeScript** type definitions for configurable data.
+- **[@typedly/data-adapter](https://github.com/typedly/data-adapter)**: A **TypeScript** type definitions for data adapter.
+- **[@typedly/data-traits](https://github.com/typedly/data-traits)**: A **TypeScript** type definitions for data traits.
+- **[@typescript-package/data](https://github.com/typescript-package/data)**: A lightweight **TypeScript** library for basic data management.
+- **[@typescript-package/collection](https://github.com/typescript-package/collection)**: A lightweight **TypeScript** library for data collection.
 
 ## Installation
 
@@ -70,179 +94,182 @@ npm install @typedly/data --save-peer
 
 ```typescript
 import {
-  // Data adapter constructor.
-  DataAdapterConstructor,
+  // Configuration
+  DataConfig,
+  DataSettings,
 
-  // Data Constructor.
-  AdaptableDataConstructor,
-  DataConstructor,
-
-  // Value Constructor.
-  ValueConstructor,
+// Inference.
+  InferAsync,
+  InferAsyncOf,
+  InferValue,
 
-  // Data adapter Interface.
-  DataAdapterShape,
+  // Iterable.
+  IterValue,
+  IterableElement,
 
-  // Data Interface.
-  AdaptableDataShape,
+  // Data.
+  DataConstructor,
   DataShape,
 
-  // Value Interface.
-  ValueShape,
-
-  // Adaptable data constructor input and tuple.
-  AdaptableDataConstructorInput,
-  AdaptableDataConstructorTuple,
-
-  // Data constructor input and tuple.
+  // Return types
+  AsyncReturn,
+  // Input types
   DataConstructorInput,
   DataConstructorTuple,
 
-  // Type.
-  AsyncReturn,
-  IterValue
+  // Value.
+  ValueConstructor,
+  ValueShape,
 } from '@typedly/data';
 ```
 
-### Constructor
+### Configuration
 
-#### `AdaptableDataConstructor`
+#### `DataConfig`
 
-The constructor interface for data types with adapter.
+The type for the data configuration, which can be either a full configuration object of `C` or just an async flag.
 
 ```typescript
-import { AdaptableDataConstructor } from '@typedly/data';
+import { DataConfig } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/adaptable-data.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data.config.ts)
 
-#### `DataAdapterConstructor`
+#### `DataSettings`
 
-The constructor interface for data adapters.
+The settings for a data type.
 
 ```typescript
-import { DataAdapterConstructor } from '@typedly/data';
+import { DataSettings } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/data-adapter.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/lib/data.settings.ts)
 
-#### `DataConstructor`
+### Inference
 
-The constructor interface for data types.
+#### `InferAsyncOf`
+
+Infers the async flag from a tuple of arguments, returning true if any of the arguments has an async flag set to true.
 
 ```typescript
-import { DataConstructor } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/data.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-async-of.type.ts)
 
-#### `ValueConstructor`
+#### `InferAsync`
+
+Infers the async flag from the settings `DataSettings` or shape `DataShape`.
 
 ```typescript
-import { ValueConstructor } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/value.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-async.type.ts)
 
-### Interface
+#### `InferValue`
 
-#### `AdaptableDataShape`
-
-The shape of a data type with optional adapter.
+Infers the value type from a data shape interface.
 
 ```typescript
-import { AdaptableDataShape } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/adaptable-data.shape.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-value.type.ts)
+
+### Iterable
 
-#### `DataAdapterShape`
+#### `IterElement`
 
-The adapter interface for data types.
+The iterate element type.
 
 ```typescript
-import { DataAdapterShape } from '@typedly/data';
+import { IterElement } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data-adapter.shape.ts)
+[Source](https://github.com/typedly/data/blob/main/src/iterable/iter-element.type.ts)
 
-#### `DataShape`
+#### `IterValue`
 
-The shape of a `Data` type.
+The iterated value type.
 
 ```typescript
-import { DataShape } from '@typedly/data';
+import { IterValue } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data.shape.ts)
+[Source](https://github.com/typedly/data/blob/main/src/iterable/iter-value.type.ts)
 
-#### `ValueShape`
+### Data
 
-The shape of a `Value` type.
+#### `AsyncReturn`
+
+The conditional return type for async methods.
 
 ```typescript
-import { ValueShape } from '@typedly/data';
+import { AsyncReturn } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/value-shape.interface.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/async-return.type.ts)
 
-### Type
+#### `DataConstructorInput`
 
-#### `AdaptableDataConstructorInput`
+The input type for data constructors, with arguments support.
 
 ```typescript
-import { AdaptableDataConstructorInput } from '@typedly/data';
+import { DataConstructorInput } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/adaptable-data-constructor-input.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-input.type.ts)
+
+#### `DataConstructorTuple`
 
-#### `AdaptableDataConstructorTuple`
+The input type for data constructors, with arguments support.
 
 ```typescript
-import { AdaptableDataConstructorTuple } from '@typedly/data';
+import { DataConstructorTuple } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/adaptable-data-constructor-tuple.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-tuple.type.ts)
 
-#### `AsyncReturn`
+#### `DataConstructor`
 
-The conditional return type for async methods.
+The constructor interface for data types.
 
 ```typescript
-import { AsyncReturn } from '@typedly/data';
+import { DataConstructor } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/async-return.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/lib/data.constructor.ts)
 
-#### `DataConstructorInput`
+#### `DataShape`
 
-The input type for data constructors, with arguments support.
+The shape of a `Data` type.
 
 ```typescript
-import { DataConstructorInput } from '@typedly/data';
+import { DataShape } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-input.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data.shape.ts)
 
-#### `DataConstructorTuple`
+### Value
 
-The input type for data constructors, with arguments support.
+#### `ValueConstructor`
 
 ```typescript
-import { DataConstructorTuple } from '@typedly/data';
+import { ValueConstructor } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-tuple.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/value/lib/value.constructor.ts)
 
-#### `IterValue`
+#### `ValueShape`
 
-The iterated value type.
+The shape of a `Value` type.
 
 ```typescript
-import { IterValue } from '@typedly/data';
+import { ValueShape } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/iter-value.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/value/lib/value-shape.interface.ts)
 
 ## Contributing
 
@@ -309,11 +336,7 @@ How do I know when to release 1.0.0?
 
 ## License
 
-MIT © typedly ([license][typedly-license])
-
-## Related packages
-
-- **[@typescript-package/collection](https://github.com/typescript-package/collection)**: A lightweight TypeScript library for data collection.
+MIT © typedly ([license][package-license])
 
 ## Packages
 
@@ -329,23 +352,41 @@ MIT © typedly ([license][typedly-license])
 - **[@typescript-package/wrapped-descriptor](https://github.com/typescript-package/wrapped-descriptor)**: A lightweight **TypeScript** library for wrapped property descriptor.
 - **[@xtypescript/property](https://github.com/xtypescript/property)** - A comprehensive, reactive **TypeScript** library for precise and extensible object property control.
 
+<!-- Funding -->
+[github-badge-sponsor]: https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&link=https://github.com/sponsors/angular-package
+[github-sponsor-link]: https://github.com/sponsors/angular-package
+[patreon-badge]: https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dangularpackage%26type%3Dpatrons&style=flat
+[patreon-link]: https://www.patreon.com/join/angularpackage/checkout?fan_landing=true&rid=0
+
+<!-- Discord -->
+[discord-badge]: https://img.shields.io/discord/925168966098386944?style=social&logo=discord&label=Discord
+[discord-channel]: https://discord.com/invite/rUCR2CW75G
+
+<!-- Gitter -->
+[gitter-badge]: https://img.shields.io/gitter/room/angular-package/ap-sass?style=social&logo=gitter
+[gitter-chat]: https://app.gitter.im/#/room/#ap-sass:gitter.im
+
+<!-- Twitter -->
+[twitter-badge]: https://img.shields.io/twitter/follow/angularpackage?label=%40angularpackage&style=social
+[twitter-follow]: https://twitter.com/angularpackage
+
 <!-- This package: typedly  -->
   <!-- GitHub: badges -->
-  [typedly-badge-issues]: https://img.shields.io/github/issues/typedly/data
-  [typedly-badge-forks]: https://img.shields.io/github/forks/typedly/data
-  [typedly-badge-stars]: https://img.shields.io/github/stars/typedly/data
-  [typedly-badge-license]: https://img.shields.io/github/license/typedly/data
+  [package-badge-issues]: https://img.shields.io/github/issues/typedly/data
+  [package-badge-forks]: https://img.shields.io/github/forks/typedly/data
+  [package-badge-stars]: https://img.shields.io/github/stars/typedly/data
+  [package-badge-license]: https://img.shields.io/github/license/typedly/data
   <!-- GitHub: badges links -->
-  [typedly-issues]: https://github.com/typedly/data/issues
-  [typedly-forks]: https://github.com/typedly/data/network
-  [typedly-license]: https://github.com/typedly/data/blob/master/LICENSE
-  [typedly-stars]: https://github.com/typedly/data/stargazers
+  [package-issues]: https://github.com/typedly/data/issues
+  [package-forks]: https://github.com/typedly/data/network
+  [package-license]: https://github.com/typedly/data/blob/master/LICENSE
+  [package-stars]: https://github.com/typedly/data/stargazers
 <!-- This package -->
 
 <!-- Package: typedly -->
   <!-- npm -->
-  [typedly-npm-badge-svg]: https://badge.fury.io/gh/typedly%2Fdata.svg
-  [typedly-npm-badge]: https://badge.fury.io/js/@typedly%2Fdata
+  [package-npm-badge-svg]: https://badge.fury.io/gh/typedly%2Fdata.svg
+  [package-npm-badge]: https://badge.fury.io/js/@typedly%2Fdata
 
 <!-- GIT -->
 [git-semver]: http://semver.org/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedly/data",
-  "version": "5.0.0-beta",
+  "version": "5.0.0",
   "author": "wwwdev.io <dev@wwwdev.io>",
   "description": "A TypeScript type definitions package for @typescript-package/data.",
   "license": "MIT",
@@ -20,7 +20,9 @@
   },
   "keywords": [
     "@typedly",
-    "@typedly/data"
+    "@typedly/data",
+    "configuration",
+    "settings"
   ],
   "funding": [
     {

package/types/typedly-data.d.ts

@@ -1,25 +1,29 @@
 import { DataConstructor as DataConstructor$1 } from '@typedly/constructor';
 
-type AdaptableDataConstructorTuple<A extends DataAdapterShape<T, C, R>, I extends AdaptableDataShape<A, T, C, R>, C extends {
-    async?: boolean;
-} = A extends DataAdapterShape<any, infer V, any> ? V : any, T = A extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = readonly [AdaptableDataConstructor<A, I, C, T, R, G>, ...G];
-
-type AdaptableDataConstructorInput<A extends DataAdapterShape<T, C, R>, I extends AdaptableDataShape<A, T, C, R>, C extends {
-    async?: boolean;
-} = A extends DataAdapterShape<any, infer V, any> ? V : any, T = A extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = AdaptableDataConstructor<A, I, C, T, R, G> | AdaptableDataConstructorTuple<A, I, C, T, R, G>;
+/**
+ * @description The settings for a data type.
+ * @export
+ * @interface DataSettings
+ * @template {boolean} [R=false] The async flag.
+ */
+interface DataSettings<R extends boolean = false> {
+    /**
+     * @description Optional async flag to indicate whether the data type is asynchronous.
+     * @default false
+     * @type {?R}
+     */
+    async?: R;
+}
 
 /**
  * @description The type to provide data constructor with arguments.
  * @export
- * @template {DataShape<T, C, R>} I The type of the data instance.
- * @template {{ async?: boolean }} [C=I extends DataShape<any, infer V, any> ? V : any] The type of the configuration, inferred from I if possible.
- * @template [T=I extends DataShape<infer U, any, any> ? U : any] The type of value instance, inferred from I if possible.
- * @template {boolean} [R=I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false] The type of the readonly flag, inferred from I if possible.
- * @template {readonly any[]} [G=any[]] The type of the arguments tuple.
+ * @template {DataShape<T, R>} I The type of the data instance.
+ * @template [T=InferValue<I>] The type of value instance, inferred from I if possible.
+ * @template {boolean} [R=InferAsync<I>] The type of the readonly flag, inferred from I if possible.
+ * @template {readonly any[]} [G=[]] The type of the arguments tuple.
  */
-type DataConstructorTuple<I extends DataShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataShape<any, infer V, any> ? V : any, T = I extends DataShape<infer U, any, any> ? U : any, R extends boolean = I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = [DataConstructor<I, C, T, R, G>, ...G];
+type DataConstructorTuple<I extends DataShape<T, R>, T = InferValue<I>, R extends boolean = InferAsync<I>, G extends readonly any[] = []> = [DataConstructor<I, T, R, G>, ...G];
 
 /**
  * @description The input type for data constructors, with arguments support.
@@ -28,53 +32,38 @@ type DataConstructorTuple<I extends DataShape<T, C, R>, C extends {
  * @template {{ async?: boolean }} [C=I extends DataShape<any, infer V, any> ? V : any] The type of the configuration, inferred from I if possible.
  * @template [T=I extends DataShape<infer U, any, any> ? U : any] The type of value instance, inferred from I if possible.
  * @template {boolean} [R=I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false] The type of the readonly flag, inferred from I if possible.
- * @template {readonly any[]} [G=any[]] The type of the arguments tuple.
+ * @template {readonly any[]} [G=[]] The type of the arguments tuple.
  */
-type DataConstructorInput<I extends DataShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataShape<any, infer V, any> ? V : any, T = I extends DataShape<infer U, any, any> ? U : any, R extends boolean = I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = DataConstructor<I, C, T, R, G> | DataConstructorTuple<I, C, T, R, G>;
+type DataConstructorInput<I extends DataShape<T, R>, T = I extends DataShape<infer U, any> ? U : any, R extends boolean = InferAsync<I>, G extends readonly any[] = []> = DataConstructor<I, T, R, G> | DataConstructorTuple<I, T, R, G>;
 
 /**
  * @description The conditional return type for async methods.
  * @export
- * @template Async The boolean flag indicating if the return type should be a Promise.
+ * @template {boolean} R The boolean flag indicating if the return type should be a `Promise`.
  * @template T The type of the value to be returned.
  */
-type AsyncReturn<Async, T> = Async extends true ? Promise<T> : T;
-
-/**
- * @description The iterated value type.
- * @export
- * @template T The type of iterated value constrained by the `Iterable` type.
- */
-type IterValue<T> = T extends Iterable<infer U> ? U : T;
+type AsyncReturn<R extends boolean, T> = R extends true ? Promise<T> : T;
 
 /**
  * @description The shape of a data type.
  * @export
  * @interface DataShape
  * @template T The value type.
- * @template C The configuration type.
- * @template {boolean} [R=C extends { async?: boolean } ? C['async'] extends boolean ? C['async'] : false : false] The `Promise` return type for methods.
+ * @template {boolean} [R=false] The async flag.
  */
-interface DataShape<T, C, R extends boolean = C extends {
-    async?: boolean;
-} ? C['async'] extends boolean ? C['async'] : false : false> {
+interface DataShape<T, R extends boolean = false> {
     /**
      * @description Indicates whether the methods return a `Promise`.
+     * @readonly
      * @type {R}
      */
-    async: R;
-    /**
-     * @description The configuration of the `Data` instance.
-     * @type {?C}
-     */
-    configuration?: C;
+    readonly async: R;
     /**
      * @description The value of the `Data` instance.
+     * @readonly
      * @type {T}
      */
-    value: T;
+    readonly value: T;
     /**
      * @description Clears the value of the `Data` instance.
      * @returns {AsyncReturn<R, this>}
@@ -92,7 +81,7 @@ interface DataShape<T, C, R extends boolean = C extends {
     getValue(): AsyncReturn<R, T>;
     /**
      * @description Locks the `Data` instance, preventing any further modifications to its value.
-     * @returns {this}
+     * @returns {this} The `Data` instance at the time of locking.
      */
     lock(): this;
     /**
@@ -101,110 +90,86 @@ interface DataShape<T, C, R extends boolean = C extends {
      * @returns {AsyncReturn<R, this>}
      */
     setValue(value: T): AsyncReturn<R, this>;
-    /**
-     * @description The string tag of the `Data` instance.
-     * @type {?string}
-     */
-    [Symbol.toStringTag]?: string;
-    /**
-     * @description The iterator method for the `Data` instance, allowing it to be iterable.
-     * @returns {IterableIterator<IterValue<T>>}
-     */
-    [Symbol.iterator]?(): IterableIterator<IterValue<T>>;
-    /**
-     * @description The asynchronous iterator method for the `Data` instance, allowing it to be asynchronously iterable.
-     * @returns {AsyncIterableIterator<IterValue<T>>}
-     */
-    [Symbol.asyncIterator]?(): AsyncIterableIterator<IterValue<T>>;
 }
 
 /**
- * @description The adapter interface for data types.
+ * @description The constructor interface for data types.
  * @export
- * @interface DataAdapterShape
- * @template T The type of the data value.
- * @template C The type of the configuration object.
- * @template {boolean} [R=false] The type of the return values for methods.
- * @extends {DataShape<T, C, R>}
+ * @interface DataConstructor
+ * @template {DataShape<T, R>} I The data instance type.
+ * @template [T=InferValue<I>] The data type inferred from `I`.
+ * @template {boolean} [R=InferAsync<I>] The async flag, inferred from `I` if possible.
+ * @template {readonly any[]} [G=[]] Additional arguments.
  */
-interface DataAdapterShape<T, C, R extends boolean = C extends {
-    async?: boolean;
-} ? C['async'] extends boolean ? C['async'] : false : false> extends DataShape<T, C, R> {
-    version?: string;
+interface DataConstructor<I extends DataShape<T, R>, T = InferValue<I>, R extends boolean = InferAsync<I>, G extends readonly any[] = []> {
+    new (
+    /** The optional initial value for the data instance. */
+    value: T, 
+    /** Additional arguments for the constructor. */
+    ...args: G): I;
 }
 
 /**
- * @description The shape of a data type with optional adapter.
+ * @description Infers the async flag from the settings `DataSettings` or shape `DataShape`.
  * @export
- * @interface AdaptableDataShape
- * @template {DataAdapterShape<T, C, any>} A The adapter type.
- * @template [T=A extends DataAdapterShape<infer U, any, any> ? U : any] The value type.
- * @template [C=A extends DataAdapterShape<any, infer V, any> ? V : any] The configuration type.
- * @template {boolean} [R=A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false] The async flag.
- * @extends {DataShape<T, C, R>}
+ * @template T The type of the configuration object.
+ * @template F The default async flag if it cannot be inferred from T.
  */
-interface AdaptableDataShape<A extends DataAdapterShape<T, C, any> | undefined = undefined, T = A extends DataAdapterShape<infer U, any, any> ? U : any, C = A extends DataAdapterShape<any, infer V, any> ? V : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false> extends DataShape<T, C, R> {
-    adapter?: A;
-}
+type InferAsync<T = undefined, F = false> = T extends DataSettings<infer R extends boolean> ? R : T extends DataShape<any, infer R extends boolean> ? R : F;
 
 /**
- * @description The value shape.
+ * @description Infers the async flag from a tuple of arguments, returning true if any of the arguments has an async flag set to true.
  * @export
- * @interface ValueShape
- * @template Type The type of value.
+ * @template {readonly any[]} A The tuple of arguments to infer the async flag from.
+ * @template [F=false] The default async flag value if the tuple is empty.
  */
-interface ValueShape<Type> {
-    get value(): Type;
-    set(value: Type): this;
-}
+type InferAsyncOf<A extends readonly any[], F = false> = A extends [infer Head, ...infer Tail] ? InferAsync<Head> extends true ? true : InferAsyncOf<Tail> : F;
 
 /**
- * @description The constructor interface for data adapters.
+ * @description Infers the value type from a data shape interface.
+ * It checks if the input type `I` extends `DataShape` and extracts the value type accordingly.
+ * If none of the conditions match, it returns the fallback type `F`.
  * @export
- * @interface DataAdapterConstructor
- * @template {DataAdapterShape<T, C, R>} I The data adapter instance type.
- * @template {{ async?: boolean }} [C=I extends DataAdapterShape<any, infer V, any> ? V : any] The configuration type, inferred from I if possible.
- * @template [T=I extends DataAdapterShape<infer U, any, any> ? U : any] The underlying value type, inferred from I if possible.
- * @template {boolean} [R=I extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false] The async flag, inferred from I if possible.
- * @template {readonly any[]} [G=any[]] Additional arguments.
+ * @template I The data shape type.
+ * @template [F=any] The fallback type if inference fails.
  */
-interface DataAdapterConstructor<I extends DataAdapterShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataAdapterShape<any, infer V, any> ? V : any, T = I extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = I extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> {
-    new (settings: C, value: T, ...args: G): I;
-}
+type InferValue<I, F = any> = I extends DataShape<infer T> ? T : I extends {
+    value?: infer V;
+} ? V : F;
 
 /**
- * @description The constructor interface for data types with adapter.
+ * @description The type for the data configuration, which can be either a full configuration object of `C` or just an async flag.
  * @export
- * @interface AdaptableDataConstructor
- * @template {DataAdapterShape<T, C, R>} A The data adapter instance type.
- * @template {AdaptableDataShape<A, T, C, R>} I The data instance type.
- * @template {{ async?: boolean }} [C=A extends DataAdapterShape<any, infer V, any> ? V : any] The configuration type, inferred from A if possible.
- * @template [T=A extends DataAdapterShape<infer U, any, any> ? U : any] The underlying value type, inferred from A if possible.
- * @template {boolean} [R=A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false] The async flag, inferred from A if possible.
- * @template {readonly any[]} [G=any[]] The additional arguments type.
+ * @template {DataSettings<R> | undefined} C The type of the settings for configuration.
+ * @template {boolean} [R=InferAsync<C>] The type of the async flag.
  */
-interface AdaptableDataConstructor<A extends DataAdapterShape<T, C, R>, I extends AdaptableDataShape<A, T, C, R>, C extends {
-    async?: boolean;
-} = A extends DataAdapterShape<any, infer V, any> ? V : any, T = A extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> {
-    new (settings: C, value: T, adapter: DataAdapterConstructor<A, C, T, R, G>, ...args: G): I;
-}
+type DataConfig<C extends DataSettings<R> | undefined, R extends boolean = InferAsync<C>> = C extends DataSettings<R> ? Required<C> : {
+    async: R;
+};
 
 /**
- * @description The constructor interface for data types.
+ * @description The iterate element type.
  * @export
- * @interface DataConstructor
- * @template {DataShape<T, C, R>} I The data instance type.
- * @template {{ async?: boolean }} C The configuration type, inferred from `I` if possible.
- * @template T The underlying value type, inferred from `I` if possible.
- * @template {boolean} [R=C['async'] extends boolean ? C['async'] : false] The async flag, inferred from `I` if possible.
- * @template {readonly any[]} [G=any[]] Additional arguments.
+ * @template T The type of the iterable.
+ */
+type IterableElement<T> = T extends Iterable<infer U> ? U : T;
+
+/**
+ * @description The iterated value type.
+ * @export
+ * @template T The type of iterated value constrained by the `Iterable` type.
+ */
+type IterValue<T> = IterableElement<T>;
+
+/**
+ * @description The value shape.
+ * @export
+ * @interface ValueShape
+ * @template T The type of value.
  */
-interface DataConstructor<I extends DataShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataShape<any, infer V, any> ? V : any, T = I extends DataShape<infer U, any, any> ? U : any, R extends boolean = I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> {
-    new (settings: C, value: T, ...args: G): I;
+interface ValueShape<T> {
+    get value(): T;
+    set(value: T): this;
 }
 
 /**
@@ -219,4 +184,4 @@ interface DataConstructor<I extends DataShape<T, C, R>, C extends {
 interface ValueConstructor<T, I extends ValueShape<T>, G extends readonly any[] = any[]> extends DataConstructor$1<T, ValueShape<T>, I, [...G]> {
 }
 
-export type { AdaptableDataConstructor, AdaptableDataConstructorInput, AdaptableDataConstructorTuple, AdaptableDataShape, AsyncReturn, DataAdapterConstructor, DataAdapterShape, DataConstructor, DataConstructorInput, DataConstructorTuple, DataShape, IterValue, ValueConstructor, ValueShape };
+export type { AsyncReturn, DataConfig, DataConstructor, DataConstructorInput, DataConstructorTuple, DataSettings, DataShape, InferAsync, InferAsyncOf, InferValue, IterValue, IterableElement, ValueConstructor, ValueShape };