@strapi/types 5.0.0-beta.0 → 5.0.0-beta.10

package/dist/uid/index.d.ts

@@ -0,0 +1,168 @@
+import type * as Internal from '../internal';
+import type * as Struct from '../struct';
+import type { Constants, Guard, Object, Extends, Or } from '../utils';
+import type * as Public from '../public';
+/**
+ * Combines ContentType and Component UID types in a single union type.
+ *
+ * `UID.Schema` provides the ability to deal with both content types and components through one streamlined type.
+ *
+ * It hinges on underlying schema registries, which aggregates and maps unique identifiers to their respective schemas.
+ *
+ * This type would typically be used where the context is not particular about dealing with content types or components exclusively but rather any kind of schema.
+ *
+ * @example
+ * Let's assume we need a function that processes schema irrespective of whether it's ContenType or Component.
+ *
+ * ```typescript
+ * import type { UID } from '@strapi/types';
+ *
+ * function processSchema(schemaID: UID.Schema) {
+ *     // Implementation goes here...
+ * }
+ *
+ * // Now, calling processSchema() with uid of content type
+ * processSchema('api::foo.foo');
+ *
+ * // And calling processSchema() with uid of component
+ * processSchema('default.foo');
+ * ```
+ *
+ * @see {@link ContentType} Identifier for content types based on the public registry.
+ * @see {@link Component} Identifier for components based on the public registry.
+ */
+export type Schema = ContentType | Component;
+/**
+ * Unique identifiers for any content-type defined in the public content-type registry.
+ *
+ * Useful when it's required to work with data structures that can only be identified by the underlying content-type UID.
+ *
+ * When no content-types are declared in the registry, it uses the generic {@link Internal.UID.ContentType} instead.
+ *
+ * @example
+ * Here's an example of how to use the `UID.ContentType` type:
+ *
+ * ```typescript
+ * import type { UID } from '@strapi/types';
+ *
+ * // Assume we have a function that requires a ContentType UID
+ * function fetchSchema(uid: UID.ContentType) {
+ *   // Implementation goes here...
+ * }
+ *
+ * // Now you can pass the unique identifier for a content type to fetch its schema
+ * fetchSchema('api::foo.foo');
+ * ```
+ * @see {@link Public.ContentTypeSchemas} Content-type public registry.
+ * @see {@link UID.ContentType} ContentType UID format definition.
+ */
+export type ContentType = Internal.Registry.Keys<Public.ContentTypeSchemas, Internal.UID.ContentType>;
+/**
+ * Unique identifiers for any component defined in the public component registry.
+ *
+ * Useful when it's required to work with data structures that can only be identified by the underlying component UID.
+ *
+ * When no component are declared in the registry, it uses the generic {@link Internal.UID.Component} instead.
+ *
+ * @example
+ * Here's an example of how to use the `UID.Component` type:
+ *
+ * ```typescript
+ * import type { UID } from '@strapi/types';
+ *
+ * // Assume we have a function that requires a Component UID
+ * function fetchSchema(uid: UID.Component) {
+ *   // Implementation goes here...
+ * }
+ *
+ * // Now you can pass the unique identifier for a component to fetch its schema
+ * fetchSchema('default.foo');
+ * ```
+ * @see {@link Public.ComponentSchemas} Component public registry.
+ * @see {@link UID.Component} Component UID format definition.
+ */
+export type Component = Internal.Registry.Keys<Public.ComponentSchemas, Internal.UID.Component>;
+/**
+ * Obtains a union of every component's category from the public component registry.
+ *
+ * It utilizes [conditional types inference](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#inferring-within-conditional-types) to extract the category name from the components' UID.
+ *
+ * The component UID format is a string that follows a specific pattern defined by {@link Internal.UID.Component}.
+ * If a type extends `Internal.UID.Component`, it implies that it has a structure with `TCategory` string as the category name of the component.
+ *
+ * @see {@link Internal.UID.Component} for more details on how the component's unique identifier is structured.
+ */
+export type ComponentCategory = Component extends Internal.UID.Component<infer TCategory> ? TCategory : never;
+/**
+ * Collection-Type UID based on the public content-type registry
+ *
+ * If no collection type is found, it fallbacks to a generic content-type UID.
+ */
+export type CollectionType = Guard.Never<Extract<Object.KeysBy<Public.ContentTypeSchemas, Struct.CollectionTypeSchema>, ContentType>, Internal.UID.ContentType>;
+/**
+ * Single-Type UID based on the public content-type registry
+ *
+ * If no single type is found, it falls back to a generic content-type UID.
+ */
+export type SingleType = Guard.Never<Extract<Object.KeysBy<Public.ContentTypeSchemas, Struct.SingleTypeSchema>, ContentType>, Internal.UID.ContentType>;
+/**
+ * Service UID based on the public service registry
+ *
+ * @see {Public.Services}
+ */
+export type Service = Internal.Registry.Keys<Public.Services, Internal.UID.Service>;
+/**
+ * Controller UID based on the public service registry
+ *
+ * @see {Public.Controllers}
+ */
+export type Controller = Internal.Registry.Keys<Public.Controllers, Internal.UID.Controller>;
+/**
+ * Policy UID based on the public service registry
+ *
+ * @see {Public.Policies}
+ */
+export type Policy = Internal.Registry.Keys<Public.Policies, Internal.UID.Policy>;
+/**
+ * Middleware UID based on the public service registry
+ *
+ * @see {Public.Middlewares}
+ */
+export type Middleware = Internal.Registry.Keys<Public.Middlewares, Internal.UID.Middleware>;
+/**
+ * Verifies if a certain schema UIDs correspond to a collection type.
+ *
+ * Given a schema UID, it checks if it matches the {@link CollectionType} UID type. Since {@link CollectionType}
+ * can resolve to the more generic {@link ContentType} type, we also need to check that the associated
+ * schema extends the {@link Struct.CollectionTypeSchema} data structure.
+ *
+ * @template TSchemaUID - The UID of the schema
+ */
+export type IsCollectionType<TSchemaUID extends Schema> = TSchemaUID extends CollectionType ? Extends<Public.ContentTypeSchemas[TSchemaUID], Struct.CollectionTypeSchema> : Constants.False;
+/**
+ * Verifies if a certain schema UIDs correspond to a single type.
+ *
+ * Given a schema UID, it checks if it matches the {@link SingleType} UID type. Since {@link SingleType}
+ * can resolve to the more generic {@link ContentType} type, we also need to check that the associated
+ * schema extends the {@link Struct.CollectionTypeSchema} data structure.
+ *
+ * @template TSchemaUID - The UID of the schema
+ */
+export type IsSingleType<TSchemaUID extends Schema> = TSchemaUID extends SingleType ? Extends<Public.ContentTypeSchemas[TSchemaUID], Struct.SingleTypeSchema> : Constants.False;
+/**
+ * Verifies if a certain schema UIDs correspond to a component.
+ *
+ * Given a schema UID, it checks if it matches the {@link Component} UID type.
+ *
+ * @template TSchemaUID - The UID of the schema
+ */
+export type IsComponent<TSchemaUID extends Schema> = TSchemaUID extends Component ? Extends<Public.ComponentSchemas[TSchemaUID], Struct.ComponentSchema> : Constants.False;
+/**
+ * Verifies if a certain schema UIDs correspond to a content-type.
+ *
+ * Given a schema UID, it checks if it matches the {@link ContentType} UID type.
+ *
+ * @template TSchemaUID - The UID of the schema
+ */
+export type IsContentType<TSchemaUID extends Schema> = TSchemaUID extends ContentType ? Or<IsCollectionType<TSchemaUID>, IsSingleType<TSchemaUID>> : Constants.False;
+//# sourceMappingURL=index.d.ts.map

package/dist/uid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/uid/index.ts"],"names":[],"mappings":"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"}

package/dist/utils/array.d.ts

@@ -0,0 +1,80 @@
+import type { Extends, Not } from '.';
+/**
+ * The `Values` type extracts the type of the values stored in arrays or tuples.
+ *
+ * @returns A union of every value contained in the array/tuple
+ *
+ * @template TCollection - The array-like structure from which the values' type will be extracted.
+ *
+ * @example
+ * Let's suppose we have an array of numbers, and we would like to extract the type its values
+ *
+ * ```typescript
+ * type MyTuple = [1, 2, 3, 4];
+ *
+ * type TupleValues = Values<MyTuple>; // TupleValues: 1 | 2 | 3 | 4
+ * ```
+ *
+ * @example
+ * Now, let's suppose we have a regular TypeScript array, and we would like to extract its value
+ *
+ * ```typescript
+ * type MyArray = (string | number)[];
+ *
+ * type ArrayValues = Values<MyArray>; // ArrayValues: string | number
+ * ```
+ */
+export type Values<TCollection extends Array<unknown>> = TCollection extends Array<infer TValues> ? TValues : never;
+/**
+ * Checks if a given array ({@link TCollection}) is empty.
+ *
+ * @template TCollection - The array to be checked. It should extend 'Array<unknown>'.
+ *
+ * @example
+ * Validate an array that is empty:
+ * ```typescript
+ * type EmptyArray = [];
+ *
+ * type IsEmptyCheck = IsEmpty<EmptyArray>;
+ * // Result: Constants.True
+ * ```
+ *
+ * @example
+ * Validate an array that is not empty:
+ * ```typescript
+ * type NonEmptyArray = [1, 2, 3];
+ *
+ * type IsEmptyCheck = IsEmpty<NonEmptyArray>;
+ * // Result: Constants.False
+ * ```
+ */
+export type IsEmpty<TCollection extends Array<unknown>> = Extends<TCollection['length'], 0>;
+/**
+ * Checks if a given array ({@link TCollection}) is not empty.
+ *
+ * @template TCollection - The collection (array) that needs to be checked if it's not empty. It must extend 'Array<unknown>'.
+ *
+ * @see {@link Not}
+ * @see {@link IsEmpty}
+ *
+ * @example
+ * Checking non-empty array:
+ * ```typescript
+ * type NonEmptyArray = [1, 2, 3];
+ *
+ * // This type checks will result to True because
+ * // 'NonEmptyArray' is indeed not empty.
+ * type IsNotEmptyCheck = IsNotEmpty<NonEmptyArray>;
+ * ```
+ *
+ * @example
+ * Checking empty array:
+ * ```typescript
+ * type EmptyArray = [];
+ *
+ * // This type checks will result to False because 'EmptyArray' is empty.
+ * type IsNotEmptyCheck = IsNotEmpty<EmptyArray>;
+ * ```
+ */
+export type IsNotEmpty<TCollection extends Array<unknown>> = Not<IsEmpty<TCollection>>;
+//# sourceMappingURL=array.d.ts.map

package/dist/utils/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/utils/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,MAAM,CAAC,WAAW,SAAS,KAAK,CAAC,OAAO,CAAC,IACnD,WAAW,SAAS,KAAK,CAAC,MAAM,OAAO,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,OAAO,CAAC,WAAW,SAAS,KAAK,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AAE5F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,UAAU,CAAC,WAAW,SAAS,KAAK,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC"}

package/dist/utils/constants.d.ts

@@ -0,0 +1,67 @@
+import type * as Internal from '../internal';
+import type * as UID from '../uid';
+import type { NotStrictEqual, Or } from '.';
+export type True = true;
+export type False = false;
+export type BooleanValue = True | False;
+/**
+ * Determine if there's been an extension or change in either Component Registry or Content-Type Registry.
+ *
+ * It applies the compound boolean OR operation on the results derived from {@link IsComponentRegistryExtended} and {@link IsContentTypeRegistryExtended}.
+ *
+ * If either or both results are true (indicating a change or extension in the corresponding registry), it returns {@link True}; otherwise, it returns {@link False}.
+ *
+ * @example
+ * ```typescript
+ * // A change or extension in both the Component Registry and the Content-Type Registry
+ * type Example1 = AreSchemaRegistriesExtended; // Result: Constants.True
+ *
+ * // A change or extension only in the Component Registry
+ * type Example2 = IsComponentRegistryExtended; // Result: Constants.True
+ *
+ * // A change or extension only in the Content-Type Registry
+ * type Example3 = IsContentTypeRegistryExtended; // Result: Constants.True
+
+ * // No change or extension in either registries
+ * type Example4 = AreSchemaRegistriesExtended; // Result: Constants.False
+ * ```
+ *
+ * @see IsComponentRegistryExtended
+ * @see IsContentTypeRegistryExtended
+ */
+export type AreSchemaRegistriesExtended = Or<IsComponentRegistryExtended, IsContentTypeRegistryExtended>;
+/**
+ * Evaluate if the internal UIDs ({@link Internal.UID.ContentType}) and public ones ({@link UID.ContentType}) are not identical.
+ *
+ * If these two types are not the same, it indicates an extension or change has occurred in the public Content-Type Registry.
+ *
+ * The type leverages {@link NotStrictEqual} to perform this comparison accurately. The result is a type-level
+ * boolean that denotes whether there is a deviation between the two Content-Type representations.
+ *
+ * @returns Either [Constants.True](@link Constants.True) if the Content-Type Registry has been extended, else [Constants.False](@link Constants.False).
+ *
+ * @remark
+ * This type is particularly useful when there is a need to verify whether there have been extensions or changes to the Content-Type Registry
+ * after initially creating it.
+ *
+ * It allows developers to perform this check at the type level and decide what type should be resolved depending on the context
+ */
+export type IsContentTypeRegistryExtended = NotStrictEqual<Internal.UID.ContentType, UID.ContentType>;
+/**
+ * Evaluate if the internal UIDs ({@link Internal.UID.Component}) and public ones ({@link UID.Component}) are not identical.
+ *
+ * If these two types are not the same, it indicates an extension or change has occurred in the public Component Registry.
+ *
+ * The type leverages {@link NotStrictEqual} to perform this comparison accurately. The result is a type-level
+ * boolean that denotes whether there is a deviation between the two Content-Type representations.
+ *
+ * @return - Either {@link True} if the Component Registry has been extended, else {@link False}.
+ *
+ * @remark
+ * This type is particularly useful when there is a need to verify whether there have been extensions or changes to the Component Registry
+ * after initially creating it.
+ *
+ * It allows developers to perform this check at the type level and decide what type should be resolved depending on the context
+ */
+export type IsComponentRegistryExtended = NotStrictEqual<Internal.UID.Component, UID.Component>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,QAAQ,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,KAAK,GAAG,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,CAAC;AAE5C,MAAM,MAAM,IAAI,GAAG,IAAI,CAAC;AAExB,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC;AAE1B,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,2BAA2B,GAAG,EAAE,CAC1C,2BAA2B,EAC3B,6BAA6B,CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,6BAA6B,GAAG,cAAc,CACxD,QAAQ,CAAC,GAAG,CAAC,WAAW,EACxB,GAAG,CAAC,WAAW,CAChB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,2BAA2B,GAAG,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC"}