@akbarsafari00/bonyan-types 5.52.1-fa.4

package/dist/utils/string.d.ts

@@ -0,0 +1,190 @@
+import type { Extends } from './expression';
+/**
+ * Alias for any literal type (useful for template string parameters)
+ *
+ * @see {@link Split}
+ * @see {@link Suffix}
+ * @see {@link Prefix}
+ * @see {@link StartsWith}
+ * @see {@link EndsWith}
+ */
+export type Literal = string | number | bigint | boolean;
+/**
+ * Ensures that a string is not empty.
+ *
+ * @template T - The type that extends a string.
+ *
+ * @example
+ * // T is assigned a string type
+ * type A = NonEmpty<string>;
+ * // A can be any string except the empty string
+ * let a: A = "hello"; // Valid
+ * a = ""; // Error: Type '""' is not assignable to type 'NonEmpty<string>'
+ *
+ * @example
+ * // T is assigned a string literal type
+ * type B = NonEmpty<"hello">;
+ * // B can only be "hello"
+ * let b: B = "hello"; // Valid
+ * b = ""; // Error: Type '""' is not assignable to type 'NonEmpty<"hello">'
+ */
+export type NonEmpty<T extends string> = T extends '' ? never : T;
+/**
+ * Splits a given string ({@link TValue}) around occurrences of a given separator ({@link TSeparator}).
+ *
+ * The resulting type is an array where each item is a part of the original string that falls between two instances of the separator.
+ *
+ * If the string does not contain the separator, the array will contain just the original string.
+ *
+ * If the string is empty, the result is an empty array.
+ *
+ * @template TValue - The string to split. Must extend `string`.
+ * @template TSeparator - The character(s) used to determine in which locations the string should be split. Must be a `string`.
+ *
+ * @example
+ *
+ * ```typescript
+ *  type Example = Split<'a.b.c.d', '.'>;  // Output will be: ['a', 'b', 'c', 'd']
+ * ```
+ * In the above example, the string 'a.b.c.d' is split around occurrences of the '.' separator.
+ *
+ * @example
+ *
+ * ```typescript
+ *  type ExampleUnion = Split<'a.b-c', '.' | '-'>;  // Output will be: ['a', 'b-c'] | ['a.b', 'c']
+ * ```
+ * The split operation will distribute the union members and create two possible return type for the union
+ */
+export type Split<TValue extends string, TSeparator extends string> = {
+    [TSep in TSeparator]: TValue extends `${infer TLeft}${TSep}${infer TRight}` ? [TLeft, ...Split<TRight, TSep>] : TValue extends '' ? [] : [TValue];
+}[TSeparator];
+/**
+ * The `Suffix` type appends a literal suffix ({@link TSuffix}) to the end of a provided string ({@link TValue}).
+ *
+ * @template TValue - The string to add the suffix to.
+ * @template TSuffix - It extends the {@link Literal} type, and represents the suffix to append.
+ *
+ * @example
+ * ```typescript
+ * // A type that appends '.com' to a string
+ * type DomainName = Suffix<string, '.com'>;
+ * const myComDomain: DomainName = 'example.com'; // This is valid
+ * const myNetDomain: DomainName = 'example.net'; // This is not valid
+ *
+ * // A variant using `number` as literal
+ * type SuffixedNumber = Suffix<string, 1>;
+ * const mySuffixedNumber: SuffixedNumber = 'example1'; // Also valid
+ * ```
+ */
+export type Suffix<TValue extends string, TSuffix extends Literal> = `${TValue}${TSuffix}`;
+/**
+ * Prepend a literal prefix ({@link TPrefix}) to the start of a provided string ({@link TValue}).
+ *
+ * @template TValue - The string to add the prefix to.
+ * @template TPrefix - It extends the {@link Literal} type, and represents the prefix to prepend.
+ *
+ * @example
+ * ```typescript
+ * // A type that prepends 'Hello ' to a string
+ * type Greeting = Suffix<string, 'Hello '>;
+ * const greeting: Greeting = 'Hello Bob'; // This is valid
+ * const farewell: Greeting = 'Bye Bob'; // This is not valid
+ * ```
+ */
+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`
+ *
+ * @template T - Value type of the dictionary
+ *
+ * @example
+ * // Dictionary where each key is a string and is bound to a number type value.
+ * const numDict: Dict<number> = {
+ *   'a': 1,
+ *   'b': 2,
+ *   'c': 3
+ * };
+ */
+export type Dict<T> = {
+    [key: string]: T;
+};
+/**
+ * Determines if a string, represented by {@link TValue}, ends with a specific literal ({@link TSuffix}).
+ *
+ * @template TValue - The string to check.
+ * @template TSuffix - A literal which may or may not be at the end of {@link TValue}.
+ *
+ * @remark
+ * To remember easily: `String.prototype.endsWith` method but at type level.
+ *
+ * @example
+ * ```typescript
+ * type Result = EndsWith<"HelloWorld", "World">;
+ * // Output: Constants.True
+ * ```
+ *
+ * ```typescript
+ * type Result = EndsWith<"HelloWorld", "Hello">;
+ * // Output: Constants.False
+ * ```
+ */
+export type EndsWith<TValue extends string, TSuffix extends Literal> = Extends<TValue, `${string}${TSuffix}`>;
+/**
+ * Determines if a string, represented by {@link TValue}, starts with a specific literal ({@link TPrefix}).
+ *
+ * @template TValue - The string to check.
+ * @template TPrefix - A literal which may or may not be at the start of {@link TValue}.
+ *
+ * @remark
+ * To remember easily: `String.prototype.startsWith` method but at type level.
+ *
+ * @example
+ * ```typescript
+ * type IsHelloWorld = StartsWith<"Hello World", "Hello">;
+ * // Output: Constants.True
+ * ```
+ *
+ * @example
+ * ```typescript
+ * type NotHelloWorld = StartsWith<"World Hello", "Hello">;
+ * // Output: Constants.False
+ * ```
+ */
+export type StartsWith<TValue extends string, TPrefix extends Literal> = Extends<TValue, `${TPrefix}${string}`>;
+/**
+ * Combines a union of literal types with a more general type while preserving autocompletion.
+ *
+ * When using string literal unions, it maintains IDE suggestions for the literal values while
+ * still allowing any value of the base type.
+ *
+ * @template T - The literal type to suggest in autocompletion (for example, specific strings)
+ * @template U - The base type that T extends from (defaults to string)
+ *
+ * @example
+ * // Define a type for specific HTTP methods while allowing custom one's
+ * type HttpMethod = LiteralUnion<'GET' | 'POST' | 'PUT' | 'DELETE'>;
+ *
+ * // These will show up in autocompletion
+ * const method1: HttpMethod = 'GET';     // ✓ Valid
+ * const method2: HttpMethod = 'POST';    // ✓ Valid
+ *
+ * // This is also valid since any string is allowed
+ * const method3: HttpMethod = 'PATCH';   // ✓ Valid
+ *
+ * @example
+ * // Can be used with number literals too
+ * type CommonPorts = LiteralUnion<80 | 443 | 3000, number>;
+ *
+ * // Suggested in autocompletion
+ * const port1: CommonPorts = 80;         // ✓ Valid
+ * const port2: CommonPorts = 443;        // ✓ Valid
+ *
+ * // Any number is still accepted
+ * const port3: CommonPorts = 8080;       // ✓ Valid
+ *
+ * @remark
+ * This type is particularly useful for API parameters where specific values should be suggested,
+ * but custom values shouldn't be restricted.
+ */
+export type LiteralUnion<T extends U, U = string> = T | (U & NonNullable<unknown>);
+//# sourceMappingURL=string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,KAAK,CAAC,MAAM,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,IAAI;KACnE,IAAI,IAAI,UAAU,GAAG,MAAM,SAAS,GAAG,MAAM,KAAK,GAAG,IAAI,GAAG,MAAM,MAAM,EAAE,GACvE,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,GAC/B,MAAM,SAAS,EAAE,GACf,EAAE,GACF,CAAC,MAAM,CAAC;CACf,CAAC,UAAU,CAAC,CAAC;AAEd;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,SAAS,MAAM,EAAE,OAAO,SAAS,OAAO,IAAI,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC;AAE3F;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,SAAS,MAAM,EAAE,OAAO,SAAS,OAAO,IAAI,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC;AAE3F;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAA;CAAE,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,QAAQ,CAAC,MAAM,SAAS,MAAM,EAAE,OAAO,SAAS,OAAO,IAAI,OAAO,CAC5E,MAAM,EACN,GAAG,MAAM,GAAG,OAAO,EAAE,CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,MAAM,EAAE,OAAO,SAAS,OAAO,IAAI,OAAO,CAC9E,MAAM,EACN,GAAG,OAAO,GAAG,MAAM,EAAE,CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/dist/utils/tuple.d.ts

@@ -0,0 +1,19 @@
+import type { Literal } from './string';
+/**
+ * Transforms a tuple ({@link TCollection}) into a concatenated string, interlaced with a designated separator character ({@link TSeparator}).
+ *
+ * @template TCollection - Represents the array of elements to be joined.
+ * @template TSeparator - Represents the separator character used to join the elements of {@link TCollection}.
+ *
+ * @example
+ * ```typescript
+ * type R1 = Join<["John", "Doe", "Smith"], ",">; // type R1 = "John,Doe,Smith"
+ * type R2 = Join<[1, 2, 3, 4], "-">; // type R2 = "1-2-3-4"
+ * type R3 = Join<["Foo", "Bar", "Baz"], "," | "-">; // type R3 = "Foo,Bar,Baz" | "Foo-Bar-Baz"
+ * ```
+ */
+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;
+//# sourceMappingURL=tuple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../src/utils/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,IAAI,CAAC,WAAW,SAAS,OAAO,EAAE,EAAE,UAAU,SAAS,OAAO,IAAI,WAAW,SAAS;IAChG,MAAM,KAAK,SAAS,OAAO;IAC3B,GAAG,MAAM,KAAK;CACf,GACG,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,GACvB,KAAK,GACL,GAAG,KAAK,GAAG,UAAU,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,GACnD,KAAK,CAAC"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@akbarsafari00/bonyan-types",
+  "version": "5.52.1-fa.4",
+  "description": "Shared typescript types for Bonyan internal use",
+  "keywords": [
+    "strapi"
+  ],
+  "homepage": "https://www.npmjs.com/package/@akbarsafari00/bonyan-types",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "akbarsafari00",
+  "main": "./dist/index.js",
+  "source": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "run -T npm-run-all clean --parallel build:code build:types",
+    "build:code": "run -T rollup -c",
+    "build:types": "run -T tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "clean": "run -T rimraf ./dist",
+    "doc:ts": "typedoc",
+    "doc:ts:watch": "typedoc --watch",
+    "lint": "run -T eslint . --max-warnings=0",
+    "test:ts": "run -T tsc -p tsconfig.json",
+    "watch": "run -T tsc -p tsconfig.build.json -w"
+  },
+  "dependencies": {
+    "@casl/ability": "6.7.5",
+    "@koa/cors": "5.0.0",
+    "@koa/router": "12.0.2",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@strapi/database": "npm:@akbarsafari00/bonyan-database@5.52.1-fa.4",
+    "@strapi/logger": "5.52.1",
+    "@strapi/permissions": "5.52.1",
+    "@strapi/utils": "5.52.1",
+    "commander": "8.3.0",
+    "json-logic-js": "2.0.5",
+    "koa": "2.16.4",
+    "koa-body": "6.0.1",
+    "node-schedule": "2.1.1",
+    "typedoc": "0.28.19",
+    "typedoc-github-wiki-theme": "2.1.0",
+    "typedoc-plugin-markdown": "4.11.0",
+    "zod": "3.25.76"
+  },
+  "engines": {
+    "node": ">=20.0.0 <=26.x.x",
+    "npm": ">=6.0.0"
+  },
+  "private": false,
+  "optionalDependencies": {},
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}