@react-analyzer/core 0.0.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Rel1cx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,97 @@
+import ts from 'typescript';
+export { isFalseLiteralType, isTrueLiteralType } from 'ts-api-utils';
+
+declare const isAnyType: (type: ts.Type) => boolean;
+declare const isBigIntType: (type: ts.Type) => boolean;
+declare const isBooleanType: (type: ts.Type) => boolean;
+declare const isEnumType: (type: ts.Type) => boolean;
+declare const isFalsyBigIntType: (type: ts.Type) => type is ts.LiteralType & {
+    freshType: ts.FreshableType;
+    regularType: ts.FreshableType;
+    flags: ts.TypeFlags;
+    symbol: ts.Symbol;
+    pattern?: ts.DestructuringPattern;
+    aliasSymbol?: ts.Symbol;
+    aliasTypeArguments?: readonly ts.Type[];
+    getFlags: () => ts.TypeFlags;
+    getSymbol: () => ts.Symbol | undefined;
+    getProperties: () => ts.Symbol[];
+    getProperty: (propertyName: string) => ts.Symbol | undefined;
+    getApparentProperties: () => ts.Symbol[];
+    getCallSignatures: () => readonly ts.Signature[];
+    getConstructSignatures: () => readonly ts.Signature[];
+    getStringIndexType: () => ts.Type | undefined;
+    getNumberIndexType: () => ts.Type | undefined;
+    getBaseTypes: () => ts.BaseType[] | undefined;
+    getNonNullableType: () => ts.Type;
+    getConstraint: () => ts.Type | undefined;
+    getDefault: () => ts.Type | undefined;
+    isUnion: () => this is ts.UnionType;
+    isIntersection: () => this is ts.IntersectionType;
+    isUnionOrIntersection: () => this is ts.UnionOrIntersectionType;
+    isLiteral: () => this is ts.LiteralType;
+    isStringLiteral: () => this is ts.StringLiteralType;
+    isNumberLiteral: () => this is ts.NumberLiteralType;
+    isTypeParameter: () => this is ts.TypeParameter;
+    isClassOrInterface: () => this is ts.InterfaceType;
+    isClass: () => this is ts.InterfaceType;
+    isIndexType: () => this is ts.IndexType;
+    value: {
+        negative: boolean;
+        base10Value: "0";
+    };
+};
+declare const isFalsyNumberType: (type: ts.Type) => boolean;
+declare const isFalsyStringType: (type: ts.Type) => boolean;
+declare const isNeverType: (type: ts.Type) => boolean;
+declare const isNullishType: (type: ts.Type) => boolean;
+declare const isNumberType: (type: ts.Type) => boolean;
+declare const isObjectType: (type: ts.Type) => boolean;
+declare const isStringType: (type: ts.Type) => boolean;
+declare const isTruthyBigIntType: (type: ts.Type) => type is ts.LiteralType & {
+    freshType: ts.FreshableType;
+    regularType: ts.FreshableType;
+    flags: ts.TypeFlags;
+    symbol: ts.Symbol;
+    pattern?: ts.DestructuringPattern;
+    aliasSymbol?: ts.Symbol;
+    aliasTypeArguments?: readonly ts.Type[];
+    getFlags: () => ts.TypeFlags;
+    getSymbol: () => ts.Symbol | undefined;
+    getProperties: () => ts.Symbol[];
+    getProperty: (propertyName: string) => ts.Symbol | undefined;
+    getApparentProperties: () => ts.Symbol[];
+    getCallSignatures: () => readonly ts.Signature[];
+    getConstructSignatures: () => readonly ts.Signature[];
+    getStringIndexType: () => ts.Type | undefined;
+    getNumberIndexType: () => ts.Type | undefined;
+    getBaseTypes: () => ts.BaseType[] | undefined;
+    getNonNullableType: () => ts.Type;
+    getConstraint: () => ts.Type | undefined;
+    getDefault: () => ts.Type | undefined;
+    isUnion: () => this is ts.UnionType;
+    isIntersection: () => this is ts.IntersectionType;
+    isUnionOrIntersection: () => this is ts.UnionOrIntersectionType;
+    isLiteral: () => this is ts.LiteralType;
+    isStringLiteral: () => this is ts.StringLiteralType;
+    isNumberLiteral: () => this is ts.NumberLiteralType;
+    isTypeParameter: () => this is ts.TypeParameter;
+    isClassOrInterface: () => this is ts.InterfaceType;
+    isClass: () => this is ts.InterfaceType;
+    isIndexType: () => this is ts.IndexType;
+    value: ts.PseudoBigInt;
+};
+declare const isTruthyNumberType: (type: ts.Type) => boolean;
+declare const isTruthyStringType: (type: ts.Type) => boolean;
+declare const isUnknownType: (type: ts.Type) => boolean;
+
+type Variant = "any" | "bigint" | "boolean" | "enum" | "never" | "nullish" | "number" | "object" | "string" | "unknown" | "falsy bigint" | "falsy boolean" | "falsy number" | "falsy string" | "truthy bigint" | "truthy boolean" | "truthy number" | "truthy string";
+/**
+ * Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements
+ * Get the variants of an array of types.
+ * @param types The types to get the variants of
+ * @returns The variants of the types
+ */
+declare function getVariantsOfTypes(types: ts.Type[]): Set<Variant>;
+
+export { type Variant, getVariantsOfTypes, isAnyType, isBigIntType, isBooleanType, isEnumType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isNeverType, isNullishType, isNumberType, isObjectType, isStringType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType };

package/dist/index.js

@@ -0,0 +1,76 @@
+import { isTypeFlagSet, isFalseLiteralType, isTrueLiteralType } from 'ts-api-utils';
+export { isFalseLiteralType, isTrueLiteralType } from 'ts-api-utils';
+import { isMatching, P, match } from 'ts-pattern';
+import ts from 'typescript';
+
+// src/type/type-is.ts
+var isAnyType = (type) => isTypeFlagSet(type, ts.TypeFlags.TypeParameter | ts.TypeFlags.Any);
+var isBigIntType = (type) => isTypeFlagSet(type, ts.TypeFlags.BigIntLike);
+var isBooleanType = (type) => isTypeFlagSet(type, ts.TypeFlags.BooleanLike);
+var isEnumType = (type) => isTypeFlagSet(type, ts.TypeFlags.EnumLike);
+var isFalsyBigIntType = (type) => type.isLiteral() && isMatching({ value: { base10Value: "0" } }, type);
+var isFalsyNumberType = (type) => type.isNumberLiteral() && type.value === 0;
+var isFalsyStringType = (type) => type.isStringLiteral() && type.value === "";
+var isNeverType = (type) => isTypeFlagSet(type, ts.TypeFlags.Never);
+var isNullishType = (type) => isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike);
+var isNumberType = (type) => isTypeFlagSet(type, ts.TypeFlags.NumberLike);
+var isObjectType = (type) => !isTypeFlagSet(
+  type,
+  ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.TypeParameter | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never
+);
+var isStringType = (type) => isTypeFlagSet(type, ts.TypeFlags.StringLike);
+var isTruthyBigIntType = (type) => type.isLiteral() && isMatching({ value: { base10Value: P.not("0") } }, type);
+var isTruthyNumberType = (type) => type.isNumberLiteral() && type.value !== 0;
+var isTruthyStringType = (type) => type.isStringLiteral() && type.value !== "";
+var isUnknownType = (type) => isTypeFlagSet(type, ts.TypeFlags.Unknown);
+function getVariantsOfTypes(types) {
+  const variants = /* @__PURE__ */ new Set();
+  if (types.some(isUnknownType)) {
+    variants.add("unknown");
+    return variants;
+  }
+  if (types.some(isNullishType)) {
+    variants.add("nullish");
+  }
+  const booleans = types.filter(isBooleanType);
+  const boolean0 = booleans[0];
+  if (booleans.length === 1 && boolean0 != null) {
+    if (isFalseLiteralType(boolean0)) {
+      variants.add("falsy boolean");
+    } else if (isTrueLiteralType(boolean0)) {
+      variants.add("truthy boolean");
+    }
+  } else if (booleans.length === 2) {
+    variants.add("boolean");
+  }
+  const strings = types.filter(isStringType);
+  if (strings.length > 0) {
+    const evaluated = match(strings).when((types2) => types2.every(isTruthyStringType), () => "truthy string").when((types2) => types2.every(isFalsyStringType), () => "falsy string").otherwise(() => "string");
+    variants.add(evaluated);
+  }
+  const bigints = types.filter(isBigIntType);
+  if (bigints.length > 0) {
+    const evaluated = match(bigints).when((types2) => types2.every(isTruthyBigIntType), () => "truthy bigint").when((types2) => types2.every(isFalsyBigIntType), () => "falsy bigint").otherwise(() => "bigint");
+    variants.add(evaluated);
+  }
+  const numbers = types.filter(isNumberType);
+  if (numbers.length > 0) {
+    const evaluated = match(numbers).when((types2) => types2.every(isTruthyNumberType), () => "truthy number").when((types2) => types2.every(isFalsyNumberType), () => "falsy number").otherwise(() => "number");
+    variants.add(evaluated);
+  }
+  if (types.some(isEnumType)) {
+    variants.add("enum");
+  }
+  if (types.some(isObjectType)) {
+    variants.add("object");
+  }
+  if (types.some(isAnyType)) {
+    variants.add("any");
+  }
+  if (types.some(isNeverType)) {
+    variants.add("never");
+  }
+  return variants;
+}
+
+export { getVariantsOfTypes, isAnyType, isBigIntType, isBooleanType, isEnumType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isNeverType, isNullishType, isNumberType, isObjectType, isStringType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@react-analyzer/core",
+  "version": "0.0.0-next.0",
+  "description": "React Analyzer utility module for static analysis of React core APIs and patterns.",
+  "homepage": "https://github.com/Rel1cx/react-analyzer",
+  "bugs": {
+    "url": "https://github.com/Rel1cx/react-analyzer/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rel1cx/react-analyzer.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "author": "Rel1cx<dokimondex@gmail.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "./package.json"
+  ],
+  "dependencies": {
+    "ts-pattern": "^5.7.1",
+    "@react-analyzer/kit": "0.0.0-next.0",
+    "@react-analyzer/eff": "0.0.0-next.0"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.2",
+    "@types/node": "^24.0.10",
+    "tsup": "^8.5.0",
+    "type-fest": "^4.41.0",
+    "@local/configs": "0.0.0"
+  },
+  "peerDependencies": {
+    "ts-api-utils": "^2.1.0",
+    "tsl": "^1.0.18",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "bun": ">=1.2.18",
+    "node": ">=22.17.0"
+  },
+  "scripts": {
+    "build": "tsup --dts-resolve",
+    "build:docs": "typedoc",
+    "lint:publish": "publint",
+    "lint:ts": "tsl"
+  }
+}