@strapi/strapi 4.12.6 → 4.13.0-alpha.0

package/dist/types/core-api/service.d.ts

@@ -0,0 +1,64 @@
+import type { Common, Utils } from '..';
+type Entity = {
+    id: string | number;
+} & unknown;
+type PaginatedEntiies = {
+    results: Entity[];
+    pagination: {
+        page: number;
+        pageSize: number | null;
+        start?: undefined;
+        limit?: undefined;
+    } | {
+        start: number;
+        limit: number;
+        page?: undefined;
+        pageSize?: undefined;
+    };
+};
+type Data = Record<string, unknown>;
+/**
+ * Base Core-API service type
+ */
+export interface Base {
+    getFetchParams(params: object): object;
+}
+/**
+ * Generic core api service structure
+ */
+export type Generic = {
+    [key: keyof any]: unknown;
+};
+/**
+ * Core-API collection type service
+ */
+export interface CollectionType extends Base {
+    find(params: object): Promise<PaginatedEntiies>;
+    findOne(entityId: string, params: object): Promise<Entity> | Entity;
+    create(params: {
+        data: Data;
+        [key: string]: unknown;
+    }): Promise<Entity> | Entity;
+    update(entityId: string, params: {
+        data: Data;
+        [key: string]: unknown;
+    }): Promise<Entity> | Entity;
+    delete(entityId: string, params: object): Promise<Entity> | Entity;
+}
+/**
+ * Core-API single type service
+ */
+export interface SingleType extends Base {
+    find(params: object): Promise<Entity> | Entity;
+    createOrUpdate(params: {
+        data: Data;
+        [key: string]: unknown;
+    }): Promise<Entity> | Entity;
+    delete(params: object): Promise<Entity> | Entity;
+}
+export type ContentType<TContentTypeUID extends Common.UID.ContentType> = Utils.Expression.MatchFirst<[
+    Utils.Expression.Test<Common.UID.IsCollectionType<TContentTypeUID>, CollectionType>,
+    Utils.Expression.Test<Common.UID.IsSingleType<TContentTypeUID>, SingleType>
+], Base>;
+export type Extendable<TContentTypeUID extends Common.UID.ContentType> = Partial<ContentType<TContentTypeUID>> & Generic;
+export {};

package/dist/types/core-api/service.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=service.js.map

package/dist/types/core-api/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../src/types/core-api/service.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './core';
+export * as EntityService from '../services/entity-service';
+export * as CoreApi from './core-api';
+export * as Utils from './utils';
+export * as Shared from './shared';

package/dist/types/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shared = exports.Utils = exports.CoreApi = exports.EntityService = void 0;
+// Exports from core should already be modules
+__exportStar(require("./core"), exports);
+exports.EntityService = __importStar(require("../services/entity-service"));
+exports.CoreApi = __importStar(require("./core-api"));
+exports.Utils = __importStar(require("./utils"));
+exports.Shared = __importStar(require("./shared"));
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8CAA8C;AAC9C,yCAAuB;AAEvB,4EAA4D;AAE5D,sDAAsC;AACtC,iDAAiC;AACjC,mDAAmC"}

package/dist/types/shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from './registries';
+export * from './entity-service';
+export * from './plugins';

package/dist/types/shared/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./registries"), exports);
+__exportStar(require("./entity-service"), exports);
+__exportStar(require("./plugins"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/shared/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/shared/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,mDAAiC;AACjC,4CAA0B"}

package/dist/types/shared/registries.d.ts

@@ -0,0 +1,37 @@
+import { Common, Schema, UID } from '..';
+/**
+ * Shared service registry
+ */
+export interface Services {
+    [uid: UID.Service]: Common.Service;
+}
+/**
+ * Shared controller registry
+ */
+export interface Controllers {
+    [uid: UID.Controller]: Common.Controller;
+}
+/**
+ * Shared policy registry
+ */
+export interface Policies {
+    [uid: UID.Policy]: unknown;
+}
+/**
+ * Shared middleware registry
+ */
+export interface Middlewares {
+    [uid: UID.Middleware]: unknown;
+}
+/**
+ * Shared content-types registry
+ */
+export interface ContentTypes {
+    [key: UID.ContentType]: Schema.ContentType;
+}
+/**
+ * Shared component registry
+ */
+export interface Components {
+    [key: UID.Component]: Schema.Component;
+}

package/dist/types/shared/registries.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=registries.js.map

package/dist/types/shared/registries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registries.js","sourceRoot":"","sources":["../../../src/types/shared/registries.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,15 @@
+import type { Utils } from '..';
+/**
+ * Extract the array values into an union type
+ */
+export type Values<TCollection extends Array<unknown>> = TCollection extends Array<infer TValues> ? TValues : never;
+/**
+ * Checks if the size of the given collection equals 0
+ */
+export type IsEmpty<TCollection extends Array<unknown>> = Utils.Expression.Extends<TCollection['length'], 0>;
+/**
+ * Checks if the size of the given collection is not 0
+ *
+ * Returns a {@link Utils.Expression.Boolean} expression
+ */
+export type IsNotEmpty<TCollection extends Array<unknown>> = Utils.Expression.Not<IsEmpty<TCollection>>;

package/dist/types/utils/array.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=array.js.map

package/dist/types/utils/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../../../src/types/utils/array.ts"],"names":[],"mappings":""}

package/dist/types/utils/expression.d.ts

@@ -0,0 +1,42 @@
+import type { Utils } from '..';
+export type True = true;
+export type False = false;
+export type BooleanValue = True | False;
+export type IsNever<TValue> = StrictEqual<TValue, never>;
+export type IsNotNever<TValue> = Not<IsNever<TValue>>;
+export type IsTrue<TValue> = [TValue] extends [True] ? True : False;
+export type IsFalse<TValue> = [TValue] extends [False] ? True : False;
+export type StrictEqual<TValue, TMatch> = And<Extends<TValue, TMatch>, Extends<TMatch, TValue>>;
+export type Extends<TLeft, TRight> = [TLeft] extends [TRight] ? True : False;
+export type DoesNotExtends<TLeft, TRight> = Not<Extends<TLeft, TRight>>;
+export type Not<TExpression extends BooleanValue> = If<TExpression, False, True>;
+export type If<TExpression extends BooleanValue, TOnTrue, TOnFalse = never> = [
+    TExpression
+] extends [True] ? TOnTrue : TOnFalse;
+export type MatchFirst<TTests extends Test[], TDefault = never> = TTests extends [
+    infer THead extends Test,
+    ...infer TTail extends Test[]
+] ? THead extends Test<infer TExpression, infer TValue> ? If<TExpression, TValue, If<Utils.Array.IsNotEmpty<TTail>, MatchFirst<TTail, TDefault>, TDefault>> : never : never;
+export type MatchAllUnion<TTests extends Test[], TDefault = never> = TTests extends [
+    infer THead extends Test,
+    ...infer TTail extends Test[]
+] ? THead extends Test<infer TExpression, infer TValue> ? Utils.Guard.Never<If<TExpression, TValue> | If<Utils.Array.IsNotEmpty<TTail>, MatchAllUnion<TTail, TDefault>>, TDefault> : never : never;
+export type MatchAllIntersect<TTests extends Test[], TDefault = unknown> = TTests extends [
+    infer THead extends Test,
+    ...infer TTail extends Test[]
+] ? THead extends Test<infer TExpression, infer TValue> ? // Actual test case evaluation
+If<TExpression, TValue, TDefault> & If<Utils.Array.IsNotEmpty<TTail>, MatchAllIntersect<TTail, TDefault>, TDefault> : TDefault : TDefault;
+export type Test<TExpression extends BooleanValue = BooleanValue, TValue = unknown> = [
+    TExpression,
+    TValue
+];
+export type Some<TExpressions extends BooleanValue[]> = TExpressions extends [
+    infer THead extends BooleanValue,
+    ...infer TTail extends BooleanValue[]
+] ? If<Utils.Array.IsNotEmpty<TTail>, Or<THead, Some<TTail>>, Or<THead, false>> : never;
+export type Every<TExpressions extends BooleanValue[]> = TExpressions extends [
+    infer THead extends BooleanValue,
+    ...infer TTail extends BooleanValue[]
+] ? If<Utils.Array.IsNotEmpty<TTail>, And<THead, Every<TTail>>, And<THead, True>> : never;
+export type And<TLeft extends BooleanValue, TRight extends BooleanValue> = IsTrue<IsTrue<TLeft> | IsTrue<TRight>>;
+export type Or<TLeft extends BooleanValue, TRight extends BooleanValue> = Not<IsFalse<IsTrue<TLeft> | IsTrue<TRight>>>;

package/dist/types/utils/expression.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=expression.js.map

package/dist/types/utils/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","sourceRoot":"","sources":["../../../src/types/utils/expression.ts"],"names":[],"mappings":""}

package/dist/types/utils/function.d.ts

@@ -0,0 +1 @@
+export type Any = (...args: any[]) => any;

package/dist/types/utils/function.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=function.js.map

package/dist/types/utils/function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.js","sourceRoot":"","sources":["../../../src/types/utils/function.ts"],"names":[],"mappings":""}

package/dist/types/utils/guard.d.ts

@@ -0,0 +1,19 @@
+import type { Utils } from '@strapi/strapi';
+/**
+ * Assign a default value `TDefault` to `TValue` if `TValue` is of type `never`
+ *
+ * @example
+ * type X = Never<{ foo: 'bar' }, string>
+ * // { foo: 'bar' }
+ *
+ * type X = Never<never>
+ * // unknown
+ *
+ * type X = Never<never, string>
+ * // string
+ */
+export type Never<TValue, TFallback = unknown> = OfTypes<[never], TValue, TFallback>;
+export type OfTypes<TTypes extends unknown[], TValue, TFallback = unknown> = TTypes extends [
+    infer THead extends unknown,
+    ...infer TTail extends unknown[]
+] ? Utils.Expression.If<Utils.Expression.StrictEqual<TValue, THead>, TFallback, Utils.Expression.If<Utils.Array.IsNotEmpty<TTail>, OfTypes<TTail, TValue, TFallback>, TValue>> : never;

package/dist/types/utils/guard.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=guard.js.map

package/dist/types/utils/guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.js","sourceRoot":"","sources":["../../../src/types/utils/guard.ts"],"names":[],"mappings":""}

package/dist/types/utils/index.d.ts

@@ -0,0 +1,25 @@
+export * as Array from './array';
+export * as Guard from './guard';
+export * as Object from './object';
+export * as String from './string';
+export * as Function from './function';
+export * as Tuple from './tuple';
+export * as Expression from './expression';
+/**
+ * Get the type of a specific key `TKey` in `TValue`
+ *
+ * @example
+ *
+ * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'foo'>
+ * // 'bar'
+ *
+ * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'bar'>
+ * // 'foo'
+ */
+export type Get<TValue, TKey extends keyof TValue> = TValue[TKey];
+export type PartialWithThis<T> = Partial<T> & ThisType<T>;
+export type Without<TLeft, TRight> = {
+    [key in Exclude<keyof TLeft, keyof TRight>]?: never;
+};
+export type XOR<TLeft, TRight> = TLeft | TRight extends object ? (Without<TLeft, TRight> & TRight) | (Without<TRight, TLeft> & TLeft) : TLeft | TRight;
+export type Cast<TValue, TType> = TValue extends TType ? TValue : never;

package/dist/types/utils/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expression = exports.Tuple = exports.Function = exports.String = exports.Object = exports.Guard = exports.Array = void 0;
+exports.Array = __importStar(require("./array"));
+exports.Guard = __importStar(require("./guard"));
+exports.Object = __importStar(require("./object"));
+exports.String = __importStar(require("./string"));
+exports.Function = __importStar(require("./function"));
+exports.Tuple = __importStar(require("./tuple"));
+exports.Expression = __importStar(require("./expression"));
+//# sourceMappingURL=index.js.map

package/dist/types/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAiC;AACjC,iDAAiC;AACjC,mDAAmC;AACnC,mDAAmC;AACnC,uDAAuC;AACvC,iDAAiC;AACjC,2DAA2C"}

package/dist/types/utils/object.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Retrieve object's (`TValue`) keys if they extend the given `TTest` type.
+ *
+ * @example
+ * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
+ * // 'foo' | 'bar'
+ *
+ * type Base = { x: 'foo' | 'bar' };
+ * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
+ * type X = KeysBy<Obj, Base>
+ * // 'foo' | 'bar'
+ */
+export type KeysBy<TValue, TTest> = {
+    [key in keyof TValue]: TValue[key] extends TTest ? key : never;
+}[keyof TValue];
+/**
+ * Retrieve object's (`TValue`) keys if they don't extend the given `TTest` type.
+ *
+ * @example
+ * type X = KeysExcept<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
+ * // foobar
+ *
+ * type Base = { x: 'foo' | 'bar' };
+ * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
+ * type X = KeysBy<Obj, Base>
+ * // 'other'
+ */
+export type KeysExcept<TValue, TTest> = {
+    [key in keyof TValue]: TValue[key] extends TTest ? never : key;
+}[keyof TValue];
+/**
+ * Retrieve object's (`TValue`) properties if their value extends the given `TTest` type.
+ *
+ * @example
+ * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
+ * // { foo: 'bar', bar: 'foo' }
+ *
+ * type Base = { x: 'foo' | 'bar' };
+ * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
+ * type X = KeysBy<Obj, Base>
+ * // { foo: { x: 'foo' }, bar: { x: 'bar' } }
+ */
+export type PickBy<TValue, TTest> = Pick<TValue, KeysBy<TValue, TTest>>;
+export type PartialBy<TValue, TKeys extends keyof TValue> = Omit<TValue, TKeys> & Partial<Pick<TValue, TKeys>>;
+/**
+ * Retrieve object's (`TObject`) values
+ *
+ * @example
+ * type X = Values<{ foo: 'bar', bar: 'foo', foobar: 2 }>
+ * // 'bar' | 'foo' | 2
+ *
+ * type Y = Values<{ foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } }>
+ * // { x: 'foo' } | { x: 'bar' } | { x: '42' }
+ */
+export type Values<TObject extends object> = TObject[keyof TObject];
+export type DeepPartial<TObject> = TObject extends object ? {
+    [TKey in keyof TObject]?: DeepPartial<TObject[TKey]>;
+} : TObject;

package/dist/types/utils/object.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=object.js.map

package/dist/types/utils/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../../src/types/utils/object.ts"],"names":[],"mappings":""}

package/dist/types/utils/string.d.ts

@@ -0,0 +1,37 @@
+import type { Utils } from '@strapi/strapi';
+/**
+ * Alias for any literal type (useful for template string parameters)
+ */
+export type Literal = string | number | bigint | boolean;
+/**
+ * Used to check if a string includes a given literal
+ */
+export type Includes<T extends Literal> = `${string}${T}${string}`;
+/**
+ * Used to make sure the given string is not empty
+ */
+export type NonEmpty<T extends string> = T extends '' ? never : T;
+/**
+ * Split the given string into a tuple using the given `TSeparator` literal
+ */
+export type Split<TValue extends string, TSeparator extends Literal> = TValue extends `${infer TLeft}${TSeparator}${infer TRight}` ? [TLeft, ...Split<TRight, TSeparator>] : TValue extends '' ? [] : [TValue];
+/**
+ * Add a literal suffix (`TSuffix`) at the end of the given string
+ */
+export type Suffix<TValue extends string, TSuffix extends Literal> = `${TValue}${TSuffix}`;
+/**
+ * Add a literal prefix (`TPrefix`) at the beginning of the given string
+ */
+export type Prefix<TValue extends string, TPrefix extends Literal> = `${TPrefix}${TValue}`;
+/**
+ * Creates a record where every key is a string and every value is `T`
+ */
+export type Dict<T> = Record<string, T>;
+/**
+ * Checks if a given string ends with the given literal
+ */
+export type EndsWith<TValue extends string, TSuffix extends Literal> = Utils.Expression.Extends<TValue, `${string}${TSuffix}`>;
+/**
+ * Checks if a given string starts with the given literal
+ */
+export type StartsWith<TValue extends string, TPrefix extends Literal> = Utils.Expression.Extends<TValue, `${TPrefix}${string}`>;

package/dist/types/utils/string.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=string.js.map

package/dist/types/utils/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../src/types/utils/string.ts"],"names":[],"mappings":""}

package/dist/types/utils/tuple.d.ts

@@ -0,0 +1,8 @@
+import type { Literal } from './string';
+/**
+ * Aggregate the given tuple into a string, separated by the given `TSeparator` literal
+ */
+export type Join<TCollection extends unknown[], TSeparator extends Literal> = TCollection extends [
+    infer THead extends Literal,
+    ...infer TTail
+] ? TTail['length'] extends 0 ? THead : `${THead}${TSeparator}${Join<TTail, TSeparator>}` : never;

package/dist/types/utils/tuple.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tuple.js.map

package/dist/types/utils/tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../../src/types/utils/tuple.ts"],"names":[],"mappings":""}

package/dist/utils/addSlash.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (path: string) => string;
+export default _default;

package/dist/utils/addSlash.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (path) => {
+    let tmpPath = path;
+    if (typeof tmpPath !== 'string')
+        throw new Error('admin.url must be a string');
+    if (tmpPath === '' || tmpPath === '/')
+        return '/';
+    if (tmpPath[0] !== '/')
+        tmpPath = `/${tmpPath}`;
+    if (tmpPath[tmpPath.length - 1] !== '/')
+        tmpPath += '/';
+    return tmpPath;
+};
+//# sourceMappingURL=addSlash.js.map

package/dist/utils/addSlash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addSlash.js","sourceRoot":"","sources":["../../src/utils/addSlash.ts"],"names":[],"mappings":";;AAAA,kBAAe,CAAC,IAAY,EAAE,EAAE;IAC9B,IAAI,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAC/E,IAAI,OAAO,KAAK,EAAE,IAAI,OAAO,KAAK,GAAG;QAAE,OAAO,GAAG,CAAC;IAElD,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG;QAAE,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAChD,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG;QAAE,OAAO,IAAI,GAAG,CAAC;IACxD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC"}

package/dist/utils/convert-custom-field-type.d.ts

@@ -0,0 +1,3 @@
+import type { Strapi } from '../Strapi';
+declare const convertCustomFieldType: (strapi: Strapi) => void;
+export default convertCustomFieldType;

package/dist/utils/convert-custom-field-type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convertCustomFieldType = (strapi) => {
+    const allContentTypeSchemaAttributes = Object.values(strapi.contentTypes).map((schema) => schema.attributes);
+    const allComponentSchemaAttributes = Object.values(strapi.components).map((schema) => schema.attributes);
+    const allSchemasAttributes = [
+        ...allContentTypeSchemaAttributes,
+        ...allComponentSchemaAttributes,
+    ];
+    for (const schemaAttrbutes of allSchemasAttributes) {
+        for (const attribute of Object.values(schemaAttrbutes)) {
+            if (attribute.type === 'customField') {
+                const customField = strapi.container.get('custom-fields').get(attribute.customField);
+                attribute.type = customField.type;
+            }
+        }
+    }
+};
+exports.default = convertCustomFieldType;
+//# sourceMappingURL=convert-custom-field-type.js.map

package/dist/utils/convert-custom-field-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-custom-field-type.js","sourceRoot":"","sources":["../../src/utils/convert-custom-field-type.ts"],"names":[],"mappings":";;AASA,MAAM,sBAAsB,GAAG,CAAC,MAAc,EAAE,EAAE;IAChD,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,GAAG,CAC3E,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAC9B,CAAC;IAEF,MAAM,4BAA4B,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CACvE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAC9B,CAAC;IACF,MAAM,oBAAoB,GAAsB;QAC9C,GAAG,8BAA8B;QACjC,GAAG,4BAA4B;KAChC,CAAC;IAEF,KAAK,MAAM,eAAe,IAAI,oBAAoB,EAAE;QAClD,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE;YACtD,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,EAAE;gBACpC,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;gBACrF,SAAS,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;aACnC;SACF;KACF;AACH,CAAC,CAAC;AAEF,kBAAe,sBAAsB,CAAC"}

package/dist/utils/cron.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Simulate an interval by shifting a cron expression using the specified date.
+ * @param {string} rule A cron expression you want to shift.
+ * @param {Date} date The date that's gonna be used as the start of the "interval", it defaults to now.
+ * @returns The shifted cron expression.
+ */
+export declare const shiftCronExpression: (rule: string, date?: Date) => string;

package/dist/utils/cron.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shiftCronExpression = void 0;
+const fp_1 = require("lodash/fp");
+const DATE_FUNCTIONS = [
+    'getSeconds',
+    'getMinutes',
+    'getHours',
+    'getDate',
+    'getMonth',
+    'getDay',
+];
+const INTEGER_REGEX = /^\d+$/;
+const STEP_REGEX = /^\*\/\d+$/;
+const COMPONENTS = [
+    { limit: 60, zeroBasedIndices: true, functionName: 'getSeconds' },
+    { limit: 60, zeroBasedIndices: true, functionName: 'getMinutes' },
+    { limit: 24, zeroBasedIndices: true, functionName: 'getHours' },
+    { limit: 31, zeroBasedIndices: false, functionName: 'getDate' },
+    { limit: 12, zeroBasedIndices: false, functionName: 'getMonth' },
+    { limit: 7, zeroBasedIndices: true, functionName: 'getDay' },
+];
+const shift = (component, index, date) => {
+    if (component === '*') {
+        return '*';
+    }
+    const { limit, zeroBasedIndices, functionName } = COMPONENTS[index];
+    const offset = +!zeroBasedIndices;
+    const currentValue = date[functionName]();
+    if (INTEGER_REGEX.test(component)) {
+        return ((Number.parseInt(component, 10) + currentValue) % limit) + offset;
+    }
+    if (STEP_REGEX.test(component)) {
+        const [, step] = component.split('/');
+        const frequency = Math.floor(limit / Number(step));
+        const list = Array.from({ length: frequency }, (_, index) => index * Number(step));
+        return list.map((value) => ((value + currentValue) % limit) + offset).sort((a, b) => a - b);
+    }
+    // Unsupported syntax
+    return component;
+};
+/**
+ * Simulate an interval by shifting a cron expression using the specified date.
+ * @param {string} rule A cron expression you want to shift.
+ * @param {Date} date The date that's gonna be used as the start of the "interval", it defaults to now.
+ * @returns The shifted cron expression.
+ */
+const shiftCronExpression = (rule, date = new Date()) => {
+    const components = rule.trim().split(' ').filter((0, fp_1.negate)(fp_1.isEmpty));
+    const secondsIncluded = components.length === 6;
+    return components
+        .map((component, index) => shift(component, secondsIncluded ? index : index + 1, date))
+        .join(' ');
+};
+exports.shiftCronExpression = shiftCronExpression;
+//# sourceMappingURL=cron.js.map