@strapi/types 0.0.0 → 4.14.0

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

@@ -0,0 +1,19 @@
+import type { Utils } from '..';
+/**
+ * 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/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/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, TExtract extends keyof any = keyof any> = {
+    [key in keyof TValue & TExtract]: TValue[key] extends TTest ? key : never;
+}[keyof TValue & TExtract];
+/**
+ * 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, TExtract extends keyof any = keyof any> = {
+    [key in keyof TValue & TExtract]: TValue[key] extends TTest ? never : key;
+}[keyof TValue & TExtract];
+/**
+ * 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/string.d.ts

@@ -0,0 +1,39 @@
+import type { Utils } from '..';
+/**
+ * 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 an indexed object where every key is a string and every value is `T`
+ */
+export type Dict<T> = {
+    [key: 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/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/index.js

@@ -0,0 +1,2 @@
+// this is a failsafe file in case the package gets required as code
+module.exports = null;

package/package.json

@@ -1,8 +1,73 @@
 {
   "name": "@strapi/types",
-  "version": "0.0.0",
-  "description": "Strapi types",
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "version": "4.14.0",
+  "description": "Shared typescript types for Strapi internal use",
+  "keywords": [
+    "strapi"
+  ],
+  "homepage": "https://strapi.io",
+  "bugs": {
+    "url": "https://github.com/strapi/strapi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/strapi/strapi.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Strapi Solutions SAS",
+    "email": "hi@strapi.io",
+    "url": "https://strapi.io"
+  },
+  "maintainers": [
+    {
+      "name": "Strapi Solutions SAS",
+      "email": "hi@strapi.io",
+      "url": "https://strapi.io"
+    }
+  ],
+  "main": "index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist",
+    "index.js"
+  ],
+  "scripts": {
+    "build": "run -T tsc -p tsconfig.build.json",
+    "build:ts": "run build",
+    "watch": "run -T tsc -p tsconfig.build.json -w --preserveWatchOutput",
+    "clean": "run -T rimraf ./dist",
+    "prepublishOnly": "yarn clean && yarn build",
+    "lint": "run -T eslint .",
+    "test:unit": "run -T jest",
+    "test:unit:watch": "run -T jest --watch"
+  },
+  "dependencies": {
+    "@koa/cors": "3.4.3",
+    "@koa/router": "10.1.1",
+    "@strapi/database": "4.14.0",
+    "@strapi/logger": "4.14.0",
+    "@strapi/permissions": "4.14.0",
+    "@strapi/utils": "4.14.0",
+    "commander": "8.3.0",
+    "https-proxy-agent": "5.0.1",
+    "koa": "2.13.4",
+    "node-fetch": "2.7.0",
+    "node-schedule": "2.1.0",
+    "ts-zen": "https://github.com/strapi/ts-zen#66e02232f5997674cc7032ea3ee59d9864863732"
+  },
+  "devDependencies": {
+    "@types/jest": "29.5.2",
+    "@types/koa": "2.13.4",
+    "@types/koa__router": "12.0.0",
+    "@types/node-schedule": "2.1.0",
+    "eslint-config-custom": "4.14.0",
+    "tsconfig": "4.14.0",
+    "typescript": "5.2.2"
+  },
+  "engines": {
+    "node": ">=16.0.0 <=20.x.x",
+    "npm": ">=6.0.0"
+  },
+  "gitHead": "09b6d7a4b46a87142d29665052ca22ced29fa56a"
 }