xenopomp-essentials 0.5.0-canary.5 → 0.5.0-canary.6

package/cli-tools/index.cjs

@@ -0,0 +1 @@
+"use strict";const r$1=require("node:path"),zod=require("zod"),e=require("dotenv");var _documentCurrentScript=typeof document<"u"?document.currentScript:null;function _interopDefaultCompat(t){return t&&typeof t=="object"&&"default"in t?t.default:t}const r__default=_interopDefaultCompat(r$1),e__default=_interopDefaultCompat(e),o=zod.z.object({dirname:zod.z.string().optional()}),importMeta=o.parse({url:typeof document>"u"?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&_documentCurrentScript.tagName.toUpperCase()==="SCRIPT"&&_documentCurrentScript.src||new URL("cli-tools/index.cjs",document.baseURI).href});e__default.config({quiet:!0});const r=zod.z.object({DISABLE_MINIFY:zod.z.string().optional().transform(t=>t==="true")});r.parse(process.env);class PathBuilder{paths=[];pushPaths(...s){return this.paths.push(...s),this}cd(...s){return this.pushPaths(...s)}file(s){return this.pushPaths(`./${s}`)}appSource(){return importMeta.dirname?this.pushPaths(r__default.join(r__default.dirname(importMeta.dirname),"../")):this.cwd()}cwd(){return this.pushPaths(process.cwd())}clear(){return this.paths=[],this}build(){return r__default.join(...this.paths)}}exports.PathBuilder=PathBuilder;

package/cli-tools/index.d.cts

@@ -0,0 +1,60 @@
+/**
+ * Fluent interface for creating paths of application.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * import { PathBuilder } from 'xenopomp-essentials/cli-tools';
+ *
+ * const builder = new PathBuilder();
+ *
+ * const res = builder
+ *  .appSource()
+ *  .cd('./dist/src')
+ *  .file('.prettierrc')
+ *  .build();
+ *
+ *  console.log(res); //? C:/Projects/example/node_modules/xenopomp-essentials/dist/src/.prettierrc
+ */
+declare class PathBuilder {
+    private paths;
+    private pushPaths;
+    /**
+     * Pushes any custom paths to builder.
+     * @since 0.0.1
+     * @param paths
+     */
+    cd(...paths: string[]): PathBuilder;
+    /**
+     * Pushes filename to paths.
+     * @since 0.0.1
+     * @param fileName
+     */
+    file<T extends `${string}.${string}`>(fileName: T): PathBuilder;
+    /**
+     * Pushes path to compiled app directory.
+     * Is useful for cli tools that have to access files inside their bundles.
+     *
+     * It probably may take no effect (if import.meta is not available in a scope).
+     * If it is, will push cwd.
+     *
+     * @since 0.0.1
+     */
+    appSource(): PathBuilder;
+    /**
+     * Gets path of directory where script is running. In cli tools it access
+     * path, where cli tool was started.
+     * @since 0.0.1
+     */
+    cwd(): PathBuilder;
+    /**
+     * @since 0.0.1
+     */
+    clear(): PathBuilder;
+    /**
+     * @since 0.0.1
+     */
+    build(): string;
+}
+
+export { PathBuilder };

package/eslint/index.cjs

@@ -0,0 +1 @@
+"use strict";const eslintConfig=require("@antfu/eslint-config"),deepmergeTs=require("deepmerge-ts"),t=require("globals"),e=require("eslint-plugin-prettier/recommended"),compat=require("@eslint/compat"),o=require("eslint-plugin-deprecation");function _interopDefaultCompat(n){return n&&typeof n=="object"&&"default"in n?n.default:n}const t__default=_interopDefaultCompat(t),e__default=_interopDefaultCompat(e),o__default=_interopDefaultCompat(o),AUTHOR_NAME="XenoPOMP",AUTHOR_NAME_LOWER=AUTHOR_NAME.toLowerCase();async function react(){return[{files:[eslintConfig.GLOB_JSX,eslintConfig.GLOB_TSX],name:`${AUTHOR_NAME_LOWER}:react`,rules:{"react-refresh/only-export-components":"off","react/no-clone-element":"off","react/no-missing-component-display-name":"off"}}]}async function next(){const n=await eslintConfig.interopDefault(import("@next/eslint-plugin-next"));return[{name:`${AUTHOR_NAME_LOWER}:next`,plugins:{"@next/next":n},rules:{"@next/next/google-font-display":"warn","@next/next/google-font-preconnect":"warn","@next/next/next-script-for-ga":"warn","@next/next/no-async-client-component":"warn","@next/next/no-before-interactive-script-outside-document":"warn","@next/next/no-css-tags":"warn","@next/next/no-head-element":"warn","@next/next/no-html-link-for-pages":"warn","@next/next/no-img-element":"warn","@next/next/no-page-custom-font":"warn","@next/next/no-styled-jsx-in-document":"warn","@next/next/no-sync-scripts":"warn","@next/next/no-title-in-document-head":"warn","@next/next/no-typos":"warn","@next/next/no-unwanted-polyfillio":"warn","@next/next/inline-script-id":"error","@next/next/no-assign-module-variable":"error","@next/next/no-document-import-in-page":"error","@next/next/no-duplicate-head":"error","@next/next/no-head-import-in-document":"error","@next/next/no-script-component-in-head":"error"}}]}async function markdown(){return[{name:`${AUTHOR_NAME_LOWER}:markdown`,files:[eslintConfig.GLOB_MARKDOWN_CODE],rules:{"import/no-unresolved":"off","unused-imports/no-unused-imports":"off","unused-imports/no-unused-vars":"off","no-alert":"off","no-console":"off","no-restricted-imports":"off","no-undef":"off","no-unused-expressions":"off","no-unused-vars":"off","antfu/no-cjs-exports":"off","antfu/no-ts-export-equal":"off","ts/no-redeclare":"off","ts/no-unused-vars":"off","ts/no-var-requires":"off","ts/consistent-type-imports":"off"}}]}async function all(){return[{name:`${AUTHOR_NAME_LOWER}:all`,rules:{"antfu/no-cjs-exports":"off","import/prefer-default-export":"off","import/extensions":"off","no-restricted-globals":"off","node/prefer-global/process":"off","jsonc/comma-dangle":"off","style/jsx-quotes":["error","prefer-double"],"style/jsx-one-expression-per-line":["error",{allow:"single-line"}],"style/arrow-parens":["error","as-needed"],"unused-imports/no-unused-imports":"error","unused-imports/no-unused-vars":["warn",{vars:"all",varsIgnorePattern:"^_",args:"after-used",argsIgnorePattern:"^_"}],"@stylistic/indent":["error",2,{ArrayExpression:1,CallExpression:{arguments:1},flatTernaryExpressions:!1,FunctionDeclaration:{body:1,parameters:1},FunctionExpression:{body:1,parameters:1},ignoreComments:!1,ignoredNodes:["TemplateLiteral *","TSIntersectionType","TSTypeParameterInstantiation","FunctionExpression > .params[decorators.length > 0]","FunctionExpression > .params > :matches(Decorator, :not(:first-child))","ClassBody.body > PropertyDefinition[decorators.length > 0] > .key"],ImportDeclaration:1,MemberExpression:1,ObjectExpression:1,offsetTernaryExpressions:!0,outerIIFEBody:1,SwitchCase:1,VariableDeclarator:1}]}}]}async function old(){return[{name:`${AUTHOR_NAME_LOWER}:old_config`,languageOptions:{globals:{...t__default.browser,...t__default.jquery,...t__default.node,document:"readonly",navigator:"readonly",window:"readonly"}},ignores:["**/.next/*","**/node_modules/*","**/.github/*","cypress","**/__tests__/e2e/*","*.json","**/*.d.ts",".eslintrc.js","eslint.config.js",".prettierrc",".stylelintrc.js","tsconfig.json","package.json","*.md","*.config.ts","*.config.js","*.md"]},{name:`${AUTHOR_NAME_LOWER}:rules_breakup_1`,rules:{"@next/next/no-duplicate-head":"off"}},{name:`${AUTHOR_NAME_LOWER}:rules_breakup_2`,rules:{"style/operator-linebreak":"off","test/consistent-test-it":"off","test/prefer-lowercase-title":"off","style/jsx-quotes":"off","style/multiline-ternary":"off","style/indent":"off"},ignores:["cypress"]},{name:`${AUTHOR_NAME_LOWER}:prettier`,rules:{"antfu/if-newline":"off"}}]}async function prettier(){return[e__default]}async function deprecation(n,s){return[{name:"Deprecation plugin",languageOptions:{parserOptions:{project:s?.tsconfigPath??"./tsconfig.json",projectSource:!0}},plugins:{deprecation:compat.fixupPluginRules(o__default)},rules:{"deprecation/deprecation":n},files:["**/*.ts","**/*.tsx"]}]}function m(n,...s){const r=[];return n={...n,react:deepmergeTs.deepmerge(!0,n?.react),vue:deepmergeTs.deepmerge(!1,n?.vue),jsonc:deepmergeTs.deepmerge(!1,n?.jsonc),yaml:deepmergeTs.deepmerge(!1,n?.yaml),stylistic:deepmergeTs.deepmerge({semi:!0,quotes:"single"},n?.stylistic),typescript:deepmergeTs.deepmerge({overrides:{"ts/consistent-type-definitions":["error","interface"],"ts/interface-name-prefix":"off","ts/explicit-function-return-type":"off","ts/explicit-module-boundary-types":"off","ts/no-explicit-any":"off"}},n?.typescript),rules:deepmergeTs.deepmerge({"import/order":"off","react/react-in-jsx-scope":"off","react/prop-types":"off","antfu/top-level-function":"off","perfectionist/sort-imports":"off","perfectionist/sort-named-imports":"off","perfectionist/sort-named-exports":"off","antfu/consistent-chaining":"off","perfectionist/sort-exports":"off","style/no-multiple-empty-lines":"off"},n?.rules),deprecation:n?.deprecation,tsconfigPath:n?.tsconfigPath},(n.react??!0)&&r.push(react()),(n.all??!0)&&r.push(all()),(n.next??!1)&&r.push(next()),(n.markdown??!0)&&r.push(markdown()),n?.deprecation&&r.push(deprecation(n?.deprecation??"warn",{tsconfigPath:n?.tsconfigPath})),r.push(old()),r.push(prettier()),eslintConfig.antfu(n,...r,...s)}module.exports=m;

package/eslint/index.d.cts

@@ -0,0 +1,40 @@
+import { antfu, OptionsConfig, TypedFlatConfigItem } from '@antfu/eslint-config';
+import { Linter } from 'eslint';
+
+interface CustomConfig {
+    all?: boolean;
+    next?: boolean;
+}
+
+type UserConfigItem = Parameters<typeof antfu>[1];
+type Configs = ReturnType<typeof antfu>;
+
+interface CustomOptions {
+    deprecation?: Linter.RuleEntry;
+    tsconfigPath?: string;
+}
+type Options = OptionsConfig & CustomConfig & TypedFlatConfigItem & CustomOptions;
+/**
+ * XenoPOMP`s default ESLint config. Uses @antfu/eslint-config under the hood.
+ *
+ * @param options
+ * @param userConfigs
+ *
+ * @example
+ * export default xenopomp(
+ *   // Setup antfu config
+ *   {
+ *     react: true,
+ *     next: false,
+ *   },
+ *   // User configs
+ *   {
+ *     name: 'My custom config',
+ *     rules: { ... }
+ *   },
+ * );
+ */
+declare function xenopomp(options?: Options, ...userConfigs: UserConfigItem[]): Configs;
+
+export = xenopomp;
+export type { Configs, CustomConfig, Options, UserConfigItem };

package/eslint/index.d.ts

@@ -36,5 +36,5 @@ type Options = OptionsConfig & CustomConfig & TypedFlatConfigItem & CustomOption
  */
 declare function xenopomp(options?: Options, ...userConfigs: UserConfigItem[]): Configs;
 
-export { xenopomp as default };
+export = xenopomp;
 export type { Configs, CustomConfig, Options, UserConfigItem };

package/index.cjs

@@ -0,0 +1 @@
+"use strict";const transliteration=require("transliteration");function pipe(t){function e(r){return t(r)}return e.pipe=r=>pipe(i=>r(t(i))),e}function capitalize(t){return t.charAt(0).toUpperCase()+t.slice(1)}function uncapitalize(t){return t.charAt(0).toLowerCase()+t.slice(1)}const parseVersion=t=>{const e=t.match(/(\d\.){2}\d/gi)?.at(0)||null,r=t.match(/(?<=-)\w+(?=\.\d)/gi)?.at(0),i=t.match(/(?<=((\d\.){2}\d-\w+\.))\d+/gi)?.at(0);return{version:e,preid:r,prerelease:i}},transliterate=transliteration.transliterate,minmax=(t,[e,r])=>e&&t<=e?e:r&&t>=r?r:t;function jsxDotNotation(t,e){return Object.assign(t,e)}exports.capitalize=capitalize,exports.jsxDotNotation=jsxDotNotation,exports.minmax=minmax,exports.parseVersion=parseVersion,exports.pipe=pipe,exports.transliterate=transliterate,exports.uncapitalize=uncapitalize;

package/index.d.cts

@@ -0,0 +1,610 @@
+export { O as Optional, P as PromiseOr, U as Undefinable } from './shared/xenopomp-essentials.CO5lcTlK.cjs';
+import { ElementType, ComponentProps, FC, ReactNode, Dispatch, SetStateAction } from 'react';
+import { Jsonifiable } from 'type-fest';
+import * as transliteration from 'transliteration';
+
+/**
+ * Matches any object but not arrays, class instances etc.
+ * @since 0.0.1
+ */
+type AnyObject = Record<PropertyKey, unknown>;
+
+/**
+ * This type stands for empty object type.
+ *
+ * @since 0.0.1
+ * @example
+ * const message: EmptyObject = { type: string; }; // Will cause error.
+ */
+type EmptyObject = Record<PropertyKey, never>;
+
+/**
+ * Simple alias for creating function types. You can use it for type guards
+ * as representation of any function, also you can create cleaner type declarations
+ * for functions.
+ *
+ * @since 0.0.1
+ * @example
+ * type MyFn = Fn<[a: string, b: string], string>;
+ */
+type Fn<Args extends any[] = any[], Res = unknown> = (...args: Args) => Res;
+
+type ParamObj<P extends string> = Record<P, string>;
+/**
+ * Represents Next.js routing params.
+ * @since 0.0.1
+ */
+interface NextParams<P extends string> {
+    params: ParamObj<P>;
+}
+/**
+ * Represents Next.js routing search params.
+ * @since 0.0.1
+ */
+interface NextSearchParams<P extends string> {
+    searchParams: ParamObj<P>;
+}
+/**
+ * This type describes Next error page params.
+ * @since 0.0.1
+ */
+interface NextErrorParams<E extends Error = any> {
+    error: E;
+    reset: () => void;
+}
+
+/**
+ * This type wraps ComponentProps<A> to your FC.
+ *
+ * - __A__  - element type
+ * - __P__  - wrapping props
+ * - __Ex__ - excluded component props (for example, if you do not want to include 'children' prop in component)
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * type VariableComponentPropsWithChildren = ComponentProps<VariableFC<'div'>>;
+ * type VariableComponentPropsWithoutChildren = ComponentProps<VariableFC<'div', {}, 'children'>>;
+ *
+ * @example
+ * // With children
+ * const VariableComponent: VariableFC<'section', { variant?: 'default' }> = ({ variant, ...props }) => {
+ *   return <section {...props}></section>
+ * }
+ *
+ * @example
+ * // Without children
+ * const VariableComponent: VariableFC<'section', { variant?: 'default' }, 'children'> = ({ variant, ...props }) => {
+ *   return (
+ *    <section {...props}>
+ *      <div>Insert your own children</div>
+ *    </section>
+ *   );
+ * }
+ */
+type VariableFC<A extends ElementType, P = unknown, Ex extends keyof ComponentProps<A> | undefined = undefined> = FC<P & WeakOmit<ComponentProps<A>, Ex>>;
+/**
+ * Works similar to {@link VariableFC}, but return type is Promise<ReactNode>;
+ * @since 0.0.1
+ */
+type AsyncVariableFC<A extends ElementType, P = unknown, Ex extends keyof ComponentProps<A> | undefined = undefined> = AsyncFC<P & WeakOmit<ComponentProps<A>, Ex>>;
+
+/**
+ * Same as **FC** (or FunctionalComponent), but it returns Promise.
+ *
+ * @since 0.0.1
+ * @example
+ * const Header: AsyncFC<HeaderProps> = async ({}) => {
+ *   // Do async stuff here...
+ *
+ *   return <div></div>;
+ * };
+ */
+type AsyncFC<T = unknown> = ReplaceReturnType<FC<T>, Promise<ReactNode>>;
+
+/**
+ * Type of set state function from useState.
+ *
+ * @since 0.0.1
+ * @example
+ * // typeof setState => SetState<string>
+ * const [state, setState] = useState<string>('example');
+ */
+type SetState<TType> = Dispatch<SetStateAction<TType>>;
+
+/**
+ * This type allows you to make children that can be function.
+ *
+ * @since 0.0.1
+ * @example
+ * type Child = FunctionalChildren<[options: string]>;
+ * // ReactNode | ((options: string) => ReactNode)
+ */
+type FunctionalChildren<Args extends any[]> = ReactNode | ((...args: Args) => ReactNode);
+
+/**
+ * @deprecated use {@link FCProps} instead.
+ */
+type FcProps<Comp> = FCProps<Comp>;
+/**
+ * Extracts type of props from FC type.
+ *
+ * @since 0.0.1
+ * @example
+ * type Props = FcProps<FC<{ align?: boolean }>>;
+ * //   ^? { align?: boolean }
+ *
+ * type VariableProps = FcProps<VariableFC<'button', { notAlign?: boolean }>>;
+ * //   ^? {notAlign?: boolean} & Omit<ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, undefined>
+ */
+type FCProps<Comp> = Comp extends FC<infer Props> ? Props : never;
+
+/**
+ * Matches any proper React component.
+ */
+type AnyFC = FC<unknown>;
+
+/**
+ * Type that represents data-{attr} keys.
+ */
+type Attribute = `data-${string}`;
+/**
+ * Matches any proper data-{attr} keys.
+ */
+type DataAttributeShape = Record<Attribute, any>;
+/**
+ * Represents React`s data-{attr} properties for components.
+ *
+ * @example
+ * type AdditionalAttributes = DataAttributes<{ 'data-disabled': boolean }>;
+ *
+ * const attrs: AdditionalAttributes = {
+ *   'data-disabled': false, // this attr is required
+ * };
+ */
+type DataAttributes<Shape extends DataAttributeShape> = Shape;
+
+type VariableProps<A extends ElementType, P = unknown, Ex extends keyof ComponentProps<A> | undefined = undefined> = FCProps<VariableFC<A, P, Ex>>;
+
+/**
+ * Make any async func synchronous.
+ *
+ * Return never, if __Func__ is not a function, actually.
+ *
+ * @since 0.0.1
+ * @example
+ * type NormalFunc = Synchronous<(one: string, two: number) => void>; // (one: string, two: number) => void
+ * type AsyncFunc = Synchronous<(one: string, two: number) => Promise<void>>; // (one: string, two: number) => void
+ * type NotAFunc = Synchronous<'sus'>; // never
+ */
+type Synchronous<Func> = Func extends Fn ? Func extends (...args: any[]) => Promise<infer Result> ? ReplaceReturnType<Func, Result> : Func : never;
+
+/**
+ * Removes readonly from type.
+ * @since 0.0.1
+ */
+type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * @deprecated Use {@link WriteableDeep} instead.
+ */
+type DeepWriteable<T> = WriteableDeep<T>;
+/**
+ * Removes readonly from type deeply.
+ * @since 0.0.1
+ */
+type WriteableDeep<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};
+
+/**
+ * Checks if type **T** matches type **M**.
+ *
+ * @since 0.0.1
+ *
+ * @example Not matching
+ * type ViewStyles = {
+ *   paddingHorizontal: number
+ * }
+ *
+ * type Styles = MatchType<{}, ViewStyles>; // TSERROR
+ *
+ * @example Matching
+ * type ViewStyles = {
+ *   paddingHorizontal: number;
+ * };
+ *
+ * // No error
+ * type Styles = MatchType<
+ *   {
+ *     paddingHorizontal: number;
+ *   },
+ *   ViewStyles
+ * >;
+ */
+type MatchType<T extends M, M> = T extends M ? T : never;
+
+/**
+ * This type gets type of array`s item.
+ *
+ * @since 0.0.1
+ * @example
+ * type Super = ArrayType<string[]>; // string
+ *
+ * type Good = ArrayType<(string|number)[]>; // string | number
+ */
+type ArrayType<T> = T extends Array<infer A> ? A : never;
+type ArrayItemType<T> = ArrayType<T>;
+
+/**
+ * Get return type of function that returns Promise ((...args: any) => Promise<any>).
+ *
+ * @since 0.0.1
+ * @example
+ * const doSomething = async (): Promise<string|number> => {
+ *   return 'result';
+ * }
+ *
+ * type Something = PromiseReturnType<typeof doSomething>;
+ * // string|number
+ */
+type AsyncReturnType<F extends (...args: any[]) => Promise<any>> = Awaited<ReturnType<F>>;
+
+/**
+ * @deprecated Use {@link InjectDeep} instead.
+ */
+type DeepInject<T, I extends AnyObject> = InjectDeep<T, I>;
+/**
+ * Recursively add some type inside all keys of target type.
+ *
+ * @since 0.0.1
+ * @example
+ * type Sups = DeepInject<{ supa: { sups: number } }, { _ignore: boolean }>;
+ * const asp: Sups = { supa: { sups: 1, _ignore: false }, _ignore: false };
+ */
+type InjectDeep<T, I extends AnyObject> = T extends object ? {
+    [K in keyof T]: T[K] extends object ? T[K] & I & DeepInject<T[K], I> : T[K];
+} & I : T;
+
+/**
+ * Removes undefined from union type.
+ * @since 0.0.1
+ * @deprecated Use {@link NonNullable} instead.
+ */
+type Defined<T> = Exclude<T, undefined>;
+
+/**
+ * Return never if type does not match JSON schema.
+ *
+ * @since 0.0.1
+ * @example
+ * type Schema = Jsonish<{ sus: string; am: string; }>; // OK
+ * type AlterSchema = Jsonish<{ sus: string; am: () => {}; }>; // Causes error
+ */
+type Jsonish<T extends Jsonifiable> = T extends Jsonifiable ? T : never;
+
+/**
+ * Modifies K (Key) in T (Type), replace it with R (Replacement).
+ *
+ * @since 0.0.1
+ * @example
+ * type ExcludedStore = Modify<IStore, 'appSettings', { appName: 'Simple name' }>; // Key in IStore has been replaced with new type.
+ */
+type Modify<T, K extends keyof T, R> = Omit<T, K> & {
+    [Key in K]: R;
+};
+
+/**
+ * Make union type of T and null.
+ * @since 0.0.1
+ */
+type Nullable<T> = T | null;
+
+/**
+ * Get typeof key of Record.
+ *
+ * @since 0.0.1
+ * @example
+ * type Key = RecordKey<Record<string, number>>; // string
+ */
+type RecordKey<R extends Record<any, any>> = R extends Record<infer K, any> ? K : never;
+
+/**
+ * Get typeof value of Record.
+ *
+ * @since 0.0.1
+ * @example
+ * type Value = RecordValue<Record<string, number>>; // number
+ */
+type RecordValue<R extends Record<any, any>> = R extends Record<any, infer V> ? V : never;
+
+/**
+ * This type replace return type of function with other type.
+ *
+ * @since 0.0.1
+ * @example
+ * type StringFC<T = {}> = ReplaceReturnType<FC<T>, string>;
+ */
+type ReplaceReturnType<TFn, TR> = TFn extends (...a: infer A) => any ? (...a: A) => TR : never;
+
+/**
+ * Works as Partial, but makes only specified keys partial.
+ *
+ * @since 0.0.1
+ * @example
+ * type Super = SelectivePartial<{
+ *  name: string;
+ *  address: {
+ *    street: string;
+ *    number: number
+ *  }
+ * }, 'address'>;
+ *
+ * // Property 'address' will be partial.
+ */
+type SelectivePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/**
+ * The strict version of Omit. Allows to remove only
+ * keys that are presented in T type.
+ *
+ * @since 0.0.1
+ * @example
+ * type Tree = {
+ *   height: number;
+ *   age: number;
+ *   name: string;
+ * };
+ *
+ * // TS2344: Type 'weight' does not satisfy the constraint keyof Tree
+ * type TreeInfo = StrictOmit<Tree, 'weight'>;
+ *
+ * // Works just like usual Omit
+ * type CorrectTreeInfo = StrictOmit<Tree, 'name'>;
+ */
+type StrictOmit<T, K extends keyof T> = Omit<T, K>;
+
+/**
+ * Extracts first type from two generics. Is helper type for {@link OneOf} type.
+ * @since 0.0.1
+ */
+type OnlyFirst<F, S> = F & {
+    [Key in keyof Omit<S, keyof F>]?: never;
+};
+/**
+ * Chooses only one of types array.
+ *
+ * @since 0.0.1
+ * @example
+ * type Email = {
+ *   person: string;
+ *   content: string;
+ *   address: string;
+ * };
+ *
+ * type Mail = {
+ *   person: string;
+ *   content: string;
+ *   postCode: number;
+ * };
+ *
+ * type Letter = OneOf<[Email, Mail]>;
+ *
+ * // Will error, cause address is not assignable to type never.
+ * const email: Letter = {
+ *   person: 'person',
+ *   content: 'content',
+ *   address: '',
+ *   postCode: 12,
+ * };
+ */
+type OneOf<TypesArray extends any[], Res = never, AllProperties = MergeTypes<TypesArray>> = TypesArray extends [infer Head, ...infer Rem] ? OneOf<Rem, Res | OnlyFirst<Head, AllProperties>, AllProperties> : Res;
+
+/**
+ * Merge array of types to one type.
+ * @since 0.0.1
+ */
+type MergeTypes<TypesArray extends any[], Res = EmptyObject> = TypesArray extends [infer Head, ...infer Rem] ? MergeTypes<Rem, Res & Head> : Res;
+
+/**
+ * Allows to pass undefined as Omit`s generic. Weakly omits type.
+ *
+ * @since 0.0.1
+ * @example
+ * // Will not omit any keys
+ * type Lib = WeakOmit<{ bookCount: number; date: string }, undefined>;
+ *
+ * // Will omit
+ * type LibStrong = WeakOmit<{ bookCount: number; date: string }, 'date'>;
+ */
+type WeakOmit<Obj extends AnyObject, Keys extends keyof Obj | undefined = undefined> = Keys extends keyof Obj ? Omit<Obj, Keys> : Obj;
+
+/**
+ * Makes types don`t merging in unions.
+ *
+ * @since 0.0.1
+ * @example
+ * type Languages = 'TypeScript' | 'JavaScript' | Lenient<string>;
+ * //     ^? "TypeScript" | "JavaScript" | string
+ */
+type Lenient<T> = T & {};
+/**
+ * This type allows any string, but also saves compiler`s autocomplete
+ * feature.
+ *
+ * @since 0.0.1
+ * @example
+ * type Languages = 'TypeScript' | 'JavaScript';
+ *
+ * function handleLanguage(lang: LenientAutocomplete<Languages>) {
+ *   //                      ^? string (but autocomplete feature is still here)
+ *   console.log(lang);
+ * }
+ */
+type LenientAutocomplete<T extends string> = T | Lenient<string>;
+
+/**
+ * Presents plain object in pretty form.
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Presents object in pretty form recursively.
+ */
+type PrettifyDeep<T> = {
+    [K in keyof T]: T[K] extends AnyObject ? Prettify<PrettifyDeep<T[K]>> : T[K];
+};
+
+/**
+ * Creates pipelines of functions that will be executed only
+ * when you will call whole pipeline.
+ *
+ * @since 0.0.1
+ *
+ * @param fn
+ *
+ * @example
+ * const stringToDateAndTime = pipe(Date.parse)
+ *   .pipe(n => new Date(n))
+ *   .pipe(d => d.toDateString())
+ *   .pipe(s => s.split('T'))
+ *   .pipe(([date, time]) => ({ date, time }));
+ *
+ * const res = stringToDateAndTime('Jan 1, 2024');
+ * //     ^? {   date: string | undefined; time: string | undefined }
+ *
+ * @see https://youtu.be/bH61wRMqp-o?si=D-2Az-_dUFBxG9HG&t=429
+ */
+declare function pipe<A, B>(fn: (a: A) => B): {
+    (a: A): B;
+    pipe<C>(fn2: (b: B) => C): {
+        (a: A): C;
+        pipe<C_1>(fn2: (b: C) => C_1): {
+            (a: A): C_1;
+            pipe<C_2>(fn2: (b: C_1) => C_2): {
+                (a: A): C_2;
+                pipe<C_3>(fn2: (b: C_2) => C_3): {
+                    (a: A): C_3;
+                    pipe<C_4>(fn2: (b: C_3) => C_4): {
+                        (a: A): C_4;
+                        pipe<C_5>(fn2: (b: C_4) => C_5): {
+                            (a: A): C_5;
+                            pipe<C_6>(fn2: (b: C_5) => C_6): {
+                                (a: A): C_6;
+                                pipe<C_7>(fn2: (b: C_6) => C_7): {
+                                    (a: A): C_7;
+                                    pipe<C_8>(fn2: (b: C_7) => C_8): {
+                                        (a: A): C_8;
+                                        pipe<C_9>(fn2: (b: C_8) => C_9): {
+                                            (a: A): C_9;
+                                            pipe<C_10>(fn2: (b: C_9) => C_10): /*elided*/ any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * Capitalizes string (makes first letter uppercase).
+ * @since 0.0.1
+ */
+declare function capitalize<T extends string>(str: T): Capitalize<T>;
+/**
+ * Un-capitalizes string (makes first letter lowercase).
+ * @since 0.0.1
+ */
+declare function uncapitalize<T extends string>(str: T): Uncapitalize<T>;
+
+type Preid = 'alpha' | 'beta' | 'rc';
+interface VersionData {
+    /** Version in format: (__``x.x.x``__-beta.x) */
+    version: Nullable<string>;
+    /** Version preid. (x.x.x-__``beta``__.x) */
+    preid?: LenientAutocomplete<Preid>;
+    /** Number of pre-release. (x.x.x-beta.__``12``__) */
+    prerelease?: string;
+}
+/**
+ * Parses version with preid.
+ *
+ * @since 0.0.1
+ *
+ * @param raw
+ *
+ * @example
+ * const { version, preid } = parseVersion('0.0.0-beta.0');
+ * // version = '0.0.0'
+ * // preid = 'beta'
+ */
+declare const parseVersion: (raw: string) => VersionData;
+
+/**
+ * Transforms any given string to transliterated variant.
+ *
+ * @since 0.0.1
+ */
+declare const transliterate: transliteration.TransliterateFunction;
+
+/**
+ * Constraints number with min and max values.
+ *
+ * @example Min value
+ * console.log({
+ *   ogNum: 1, // 1
+ *   minmax: minmax(1, [2, undefined]), // 2
+ * });
+ *
+ * @example Max value
+ * console.log({
+ *   ogNum: 1001, // 1001
+ *   minmax: minmax(1001, [undefined, 900]), // 900
+ * });
+ *
+ * @example Min and max value
+ * console.log({
+ *   ogNum: 600, // 600
+ *   minmax: minmax(1001, [2, 900]), // 600
+ * });
+ */
+declare const minmax: (num: number, [min, max]: [min: number | undefined, max: number | undefined]) => number;
+
+/**
+ * Creates properly type object with jsxDotNotation.
+ *
+ * @param comp
+ * @param rest
+ *
+ * @example
+ * const FlexComp: FC<PropsWithChildren> = ({ children }) => <div>{children}</div>;
+ * const FlexRow: FC<PropsWithChildren & { short?: boolean }> = ({ children }) => (
+ *   <div>{children}</div>
+ * );
+ * const FlexCol: FC<PropsWithChildren> = ({ children }) => <div>{children}</div>;
+ *
+ * const Flex = jsxDotNotation(FlexComp, {
+ *   Row: FlexRow,
+ *   Col: FlexCol,
+ * });
+ *
+ * const Am = () => {
+ *   return (
+ *     <Flex>
+ *       <Flex.Row short>
+ *         <Flex.Col></Flex.Col>
+ *       </Flex.Row>
+ *     </Flex>
+ *   );
+ * };
+ */
+declare function jsxDotNotation<Props = EmptyObject, Rest extends Record<string, FC<any>> = EmptyObject>(comp: FC<Props>, rest: Rest): FC<Props> & Rest;
+
+export { capitalize, jsxDotNotation, minmax, parseVersion, pipe, transliterate, uncapitalize };
+export type { AnyFC, AnyObject, ArrayItemType, ArrayType, AsyncFC, AsyncReturnType, AsyncVariableFC, DataAttributes, Defined, EmptyObject, FCProps, FcProps, Fn, FunctionalChildren, InjectDeep, Jsonish, Lenient, LenientAutocomplete, MatchType, MergeTypes, Modify, NextErrorParams, NextParams, NextSearchParams, Nullable, OneOf, OnlyFirst, Preid, Prettify, PrettifyDeep, RecordKey, RecordValue, ReplaceReturnType, SelectivePartial, SetState, StrictOmit, Synchronous, VariableFC, VariableProps, VersionData, WeakOmit, Writeable, WriteableDeep };

package/next/index.cjs

@@ -0,0 +1,11 @@
+"use strict";const i=require("next/script");function _interopDefaultCompat(t){return t&&typeof t=="object"&&"default"in t?t.default:t}const i__default=_interopDefaultCompat(i),ReactScan=()=>React.createElement("script",{src:"https://unpkg.com/react-scan/dist/auto.global.js",async:!0}),Metrika=({id:t,clickMap:e=!0,trackLinks:a=!0,accurateTrackBounce:c=!0})=>React.createElement(i__default,{id:"metrika-counter",strategy:"afterInteractive"},`   (function(m,e,t,r,i,k,a){m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)};
+           m[i].l=1*new Date();
+           for (var j = 0; j < document.scripts.length; j++) {if (document.scripts[j].src === r) { return; }}
+           k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a)})
+           (window, document, "script", "https://mc.yandex.ru/metrika/tag.js", "ym");
+        
+           ym(${t}, "init", {
+                clickmap:${e},
+                trackLinks:${a},
+                accurateTrackBounce:${c}
+           });`);exports.Metrika=Metrika,exports.ReactScan=ReactScan;

package/next/index.d.cts

@@ -0,0 +1,67 @@
+import { FC } from 'react';
+
+/**
+ * Adds react-scan to your Next.js application.
+ * @constructor
+ * @since 0.0.1
+ *
+ * @example
+ * import { ReactScan } from 'xenopomp-essentials/next';
+ *
+ * export default function RootLayout({
+ *   children,
+ * }: {
+ *   children: React.ReactNode
+ * }) {
+ *   return (
+ *     <html lang="en">
+ *       <head>
+ *         <ReactScan />
+ *       </head>
+ *       <body>{children}</body>
+ *      </html>
+ *   )
+ *}
+ */
+declare const ReactScan: FC<unknown>;
+
+interface MetrikaProps {
+    /**
+     * ID of your Yandex.Metrika`s counter.
+     * Locate at dashboard.
+     */
+    id: number;
+    clickMap?: boolean;
+    trackLinks?: boolean;
+    accurateTrackBounce?: boolean;
+}
+
+/**
+ * This component allows you to use Yandex.Metrika
+ * in your Next.js projects.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * import { Metrika } from 'xenopomp-essentials/next';
+ *
+ * export default function RootLayout({
+ *   children,
+ * }: {
+ *   children: React.ReactNode
+ * }) {
+ *   return (
+ *     <html lang="en">
+ *       <head>
+ *         <Metrika id={123456789} />
+ *       </head>
+ *       <body>{children}</body>
+ *      </html>
+ *   )
+ * }
+ *
+ * @see https://metrika.yandex.ru
+ */
+declare const Metrika: FC<MetrikaProps>;
+
+export { Metrika, ReactScan };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "xenopomp-essentials",
-  "version": "0.5.0-canary.5",
+  "version": "0.5.0-canary.6",
   "author": "XenoPOMP <101574433+XenoPOMP@users.noreply.github.com>",
   "license": "MIT",
   "private": false,
+  "type": "commonjs",
   "repository": {
     "type": "git",
     "url": "https://github.com/XenoPOMP/xenopomp-essentials-js.git"
@@ -13,6 +14,7 @@
   },
   "scripts": {
     "build": "run-p build:**",
+    "postbuild": "cd ./dist ; rimraf **/*.mjs",
     "build:main": "unbuild --config .config/build.config.ts",
     "build:packages:cli": "echo CLI",
     "lint": "run-p lint:**",
@@ -93,6 +95,7 @@
     "pinst": "^3.0.0",
     "prettier": "^3.4.2",
     "react-dom": "^19.2.0",
+    "rimraf": "^6.1.2",
     "tsd": "^0.31.2",
     "unbuild": "^3.6.1",
     "vite": "^7.2.4",

package/shared/xenopomp-essentials.CO5lcTlK.d.cts

@@ -0,0 +1,14 @@
+type PromiseOr<T> = T | Promise<T>;
+
+/**
+ * Makes type union of type T and undefined
+ * @since 0.0.1
+ * @deprecated Renamed to {@link Optional}.
+ */
+type Undefinable<T> = T | undefined;
+/**
+ * Marks type as optional (undefinable).
+ */
+type Optional<T> = T | undefined;
+
+export type { Optional as O, PromiseOr as P, Undefinable as U };

package/vitest/index.cjs

@@ -0,0 +1 @@
+"use strict";const vitest=require("vitest"),react=require("@testing-library/react"),o=require("ansi-colors"),c=require("vitest-matchmedia-mock");function _interopDefaultCompat(t){return t&&typeof t=="object"&&"default"in t?t.default:t}const o__default=_interopDefaultCompat(o),c__default=_interopDefaultCompat(c),assertNotThrowing=t=>{vitest.expect(()=>t()).not.toThrow()},assertRendering=(...t)=>{assertNotThrowing(()=>react.render(...t))},assertHookRendering=(...t)=>{assertNotThrowing(()=>react.renderHook(...t))},mockEnv=t=>{vitest.vi.stubEnv("CANONICAL_URL","http://localhost:4242"),vitest.vi.stubEnv("IS_PRODUCTION","false"),t&&Object.entries(t).forEach(([e,s])=>vitest.vi.stubEnv(e,s))},clearMocks=()=>{vitest.vi.clearAllMocks(),vitest.vi.resetAllMocks(),vitest.vi.unstubAllEnvs(),vitest.vi.unstubAllGlobals()},mockRouter=()=>{vitest.vi.mock("next/navigation",()=>({useRouter:()=>({push(){}}),usePathname:()=>"/"}))},twApiMock={addBase:vitest.vi.fn(),addComponents:vitest.vi.fn(),addUtilities:vitest.vi.fn(),addVariant:vitest.vi.fn(),config:vitest.vi.fn(),corePlugins:vitest.vi.fn(),e:vitest.vi.fn(),matchComponents:vitest.vi.fn(),matchUtilities:vitest.vi.fn(),matchVariant:vitest.vi.fn(),theme:vitest.vi.fn()};class r{_executionContext;constructor(e){this._executionContext=e}call(...e){console.debug(`${o__default.blue(`[${this._executionContext}]`)} ${o__default.green(`Custom spy is called with these args: ${o__default.blueBright(e.map(s=>`${s}`).join(", "))}`)}`)}}function spyFactory(t){const e=new r(t),s=vitest.vi.spyOn(e,"call");return{expectToBeCalled:(...n)=>vitest.expect(s).toHaveBeenCalledWith(n),expectToBeNotCalled:(...n)=>vitest.expect(s).not.toHaveBeenCalledWith(n),spy:s,callSpy:(...n)=>e.call(n)}}const stubGlobal=(t,e)=>{vitest.vi.stubGlobal(t,e)},p={beforeAll:vitest.beforeAll,afterEach:vitest.afterEach},injectMocks=(t,e="beforeAll")=>{let s;p[e](()=>s=t()),vitest.afterAll(()=>{clearMocks(),s?.()})},injectMatchMediaMock=()=>{const t=new c__default;injectMocks(()=>(t.clear(),()=>t.destroy()),"afterEach")};exports.assertHookRendering=assertHookRendering,exports.assertNotThrowing=assertNotThrowing,exports.assertRendering=assertRendering,exports.clearMocks=clearMocks,exports.injectMatchMediaMock=injectMatchMediaMock,exports.injectMocks=injectMocks,exports.mockEnv=mockEnv,exports.mockRouter=mockRouter,exports.spyFactory=spyFactory,exports.stubGlobal=stubGlobal,exports.twApiMock=twApiMock;

package/vitest/index.d.cts

@@ -0,0 +1,176 @@
+import { P as PromiseOr, O as Optional } from '../shared/xenopomp-essentials.CO5lcTlK.cjs';
+import { render, renderHook } from '@testing-library/react';
+import * as vitest from 'vitest';
+import { beforeAll, afterEach, Mock } from 'vitest';
+import * as _vitest_spy from '@vitest/spy';
+import { PartialDeep } from 'type-fest';
+
+/** Executes function and expects that it won't throw. */
+declare const assertNotThrowing: <T = void>(callable: () => PromiseOr<T>) => void;
+
+type RenderArguments = Parameters<typeof render>;
+type RenderHookArguments = Parameters<typeof renderHook>;
+type RenderFunc<Args extends unknown[] = RenderArguments> = (...args: Args) => void;
+/**
+ * Renders component and expects that it won`t throw.
+ *
+ * @example
+ * test('It renders', () => {
+ *   test('It renders', () => {
+ *     assertRendering(<MyComponent />, {
+ *       wrapper: RQProvider,
+ *     });
+ *   });
+ * });
+ *
+ */
+declare const assertRendering: RenderFunc;
+/**
+ * Renders hook within test React component without having to create that component yourself.
+ * Expects that it won't throw error.
+ *
+ * @param props
+ *
+ * @example
+ * test('It renders', () => {
+ *   assertHookRendering(() => useExampleStore());
+ * });
+ */
+declare const assertHookRendering: RenderFunc<RenderHookArguments>;
+
+/**
+ * Mocks .env file.
+ *
+ * @param additionalMocks  key-value record of env variables that also have to be mocked.
+ */
+declare const mockEnv: (additionalMocks?: Record<string, string>) => void;
+
+/**
+ * Clear all mocks from Vitest.
+ */
+declare const clearMocks: () => void;
+
+/**
+ * Mock **next/navigation** package.
+ */
+declare const mockRouter: () => void;
+
+declare const twApiMock: {
+    addBase: vitest.Mock<_vitest_spy.Procedure>;
+    addComponents: vitest.Mock<_vitest_spy.Procedure>;
+    addUtilities: vitest.Mock<_vitest_spy.Procedure>;
+    addVariant: vitest.Mock<_vitest_spy.Procedure>;
+    config: vitest.Mock<_vitest_spy.Procedure>;
+    corePlugins: vitest.Mock<_vitest_spy.Procedure>;
+    e: vitest.Mock<_vitest_spy.Procedure>;
+    matchComponents: vitest.Mock<_vitest_spy.Procedure>;
+    matchUtilities: vitest.Mock<_vitest_spy.Procedure>;
+    matchVariant: vitest.Mock<_vitest_spy.Procedure>;
+    theme: vitest.Mock<_vitest_spy.Procedure>;
+};
+
+type Caller = (...args: any[]) => void;
+/**
+ * Creates custom spy factory object that is callable.
+ * @param context
+ * @example
+ * const { callSpy, expectToBeCalled, expectToBeNotCalled } =
+ *   spyFactory('spyFactory test');
+ *
+ * // Call spy with some args
+ * const args: any[] = [1, 'some', 'args', 2];
+ * callSpy(...args);
+ *
+ * // Run expectation func
+ * expectToBeCalled(...args);
+ * expectToBeNotCalled(2, 2, 7);
+ */
+declare function spyFactory(context: string): {
+    expectToBeCalled: Caller;
+    expectToBeNotCalled: Caller;
+    spy: vitest.Mock<(...args: any[]) => void>;
+    callSpy: Caller;
+};
+
+/**
+ * Mocks global scope object.
+ *
+ * @param name
+ * @param stub
+ *
+ * @example
+ * stubGlobal<typeof navigator>('navigator', {
+ *     clipboard: {
+ *       writeText: async (text: string) => vi.fn(),
+ *     },
+ * });
+ */
+declare const stubGlobal: <Global extends object>(name: string, stub: PartialDeep<Stub<Global>>) => void;
+
+type Fn = () => void;
+type Strategy = keyof typeof strategies;
+type AfterAllCallback = Optional<Fn> | void;
+/**
+ * Map of all available strategies for
+ * injectMocks function.
+ */
+declare const strategies: {
+    beforeAll: typeof beforeAll;
+    afterEach: typeof afterEach;
+};
+/**
+ * Inserts mocks according to selected strategy
+ * (default is `beforeAll`).
+ *
+ * This function takes approach of useEffect hook
+ * from React. You define mocks inside function body,
+ * then you return function, that will be called
+ * in `afterAll` event.
+ *
+ * @example
+ * injectMocks(() => {
+ *     mockRouter();
+ *
+ *     return () => {
+ *       console.log('This is printed from injectMocks func (afterAll event).');
+ *     };
+ *   });
+ */
+declare const injectMocks: (func: () => AfterAllCallback, strategy?: Strategy) => void;
+
+/**
+ * Mocks stuff related to window.matchMedia.
+ *
+ * @example
+ * describe('Root layout test', () => {
+ *   // Use it inside describe suite. Place it to top
+ *   injectMatchMediaMock();
+ *
+ *   injectMocks(() => {
+ *     vi.mock('next/font/google', () => ({
+ *       Inter: FONT_MOCK,
+ *     }));
+ *   });
+ *
+ *   testNextPage(<RootLayout children={undefined} />, {
+ *     generateMetadata,
+ *   });
+ * });
+ */
+declare const injectMatchMediaMock: () => void;
+
+/**
+ * Recursevely changes all keys` types inside T to R.
+ */
+type TypeReplaceDeep<T extends object, R> = {
+    [K in keyof T]: T[K] extends object ? TypeReplaceDeep<T[K], R> : R;
+};
+
+type StubValue = Mock | (() => Mock) | (() => Promise<Mock>);
+/**
+ * Represents vi stub object.
+ */
+type Stub<T extends object> = TypeReplaceDeep<T, StubValue>;
+
+export { assertHookRendering, assertNotThrowing, assertRendering, clearMocks, injectMatchMediaMock, injectMocks, mockEnv, mockRouter, spyFactory, stubGlobal, twApiMock };
+export type { Stub, TypeReplaceDeep };

package/cli-tools/index.mjs

@@ -1 +0,0 @@
-import s from"node:path";import{z as r}from"zod";import h from"dotenv";const o=r.object({dirname:r.string().optional()}),e=o.parse(import.meta);h.config({quiet:!0});const a=r.object({DISABLE_MINIFY:r.string().optional().transform(i=>i==="true")});a.parse(process.env);class p{paths=[];pushPaths(...t){return this.paths.push(...t),this}cd(...t){return this.pushPaths(...t)}file(t){return this.pushPaths(`./${t}`)}appSource(){return e.dirname?this.pushPaths(s.join(s.dirname(e.dirname),"../")):this.cwd()}cwd(){return this.pushPaths(process.cwd())}clear(){return this.paths=[],this}build(){return s.join(...this.paths)}}export{p as PathBuilder};

package/eslint/index.mjs

@@ -1 +0,0 @@
-import{GLOB_JSX as a,GLOB_TSX as i,interopDefault as f,GLOB_MARKDOWN_CODE as p,antfu as c}from"@antfu/eslint-config";import{deepmerge as o}from"deepmerge-ts";import s from"globals";import l from"eslint-plugin-prettier/recommended";import{fixupPluginRules as u}from"@eslint/compat";import m from"eslint-plugin-deprecation";const d="XenoPOMP",t=d.toLowerCase();async function x(){return[{files:[a,i],name:`${t}:react`,rules:{"react-refresh/only-export-components":"off","react/no-clone-element":"off","react/no-missing-component-display-name":"off"}}]}async function y(){const e=await f(import("@next/eslint-plugin-next"));return[{name:`${t}:next`,plugins:{"@next/next":e},rules:{"@next/next/google-font-display":"warn","@next/next/google-font-preconnect":"warn","@next/next/next-script-for-ga":"warn","@next/next/no-async-client-component":"warn","@next/next/no-before-interactive-script-outside-document":"warn","@next/next/no-css-tags":"warn","@next/next/no-head-element":"warn","@next/next/no-html-link-for-pages":"warn","@next/next/no-img-element":"warn","@next/next/no-page-custom-font":"warn","@next/next/no-styled-jsx-in-document":"warn","@next/next/no-sync-scripts":"warn","@next/next/no-title-in-document-head":"warn","@next/next/no-typos":"warn","@next/next/no-unwanted-polyfillio":"warn","@next/next/inline-script-id":"error","@next/next/no-assign-module-variable":"error","@next/next/no-document-import-in-page":"error","@next/next/no-duplicate-head":"error","@next/next/no-head-import-in-document":"error","@next/next/no-script-component-in-head":"error"}}]}async function g(){return[{name:`${t}:markdown`,files:[p],rules:{"import/no-unresolved":"off","unused-imports/no-unused-imports":"off","unused-imports/no-unused-vars":"off","no-alert":"off","no-console":"off","no-restricted-imports":"off","no-undef":"off","no-unused-expressions":"off","no-unused-vars":"off","antfu/no-cjs-exports":"off","antfu/no-ts-export-equal":"off","ts/no-redeclare":"off","ts/no-unused-vars":"off","ts/no-var-requires":"off","ts/consistent-type-imports":"off"}}]}async function w(){return[{name:`${t}:all`,rules:{"antfu/no-cjs-exports":"off","import/prefer-default-export":"off","import/extensions":"off","no-restricted-globals":"off","node/prefer-global/process":"off","jsonc/comma-dangle":"off","style/jsx-quotes":["error","prefer-double"],"style/jsx-one-expression-per-line":["error",{allow:"single-line"}],"style/arrow-parens":["error","as-needed"],"unused-imports/no-unused-imports":"error","unused-imports/no-unused-vars":["warn",{vars:"all",varsIgnorePattern:"^_",args:"after-used",argsIgnorePattern:"^_"}],"@stylistic/indent":["error",2,{ArrayExpression:1,CallExpression:{arguments:1},flatTernaryExpressions:!1,FunctionDeclaration:{body:1,parameters:1},FunctionExpression:{body:1,parameters:1},ignoreComments:!1,ignoredNodes:["TemplateLiteral *","TSIntersectionType","TSTypeParameterInstantiation","FunctionExpression > .params[decorators.length > 0]","FunctionExpression > .params > :matches(Decorator, :not(:first-child))","ClassBody.body > PropertyDefinition[decorators.length > 0] > .key"],ImportDeclaration:1,MemberExpression:1,ObjectExpression:1,offsetTernaryExpressions:!0,outerIIFEBody:1,SwitchCase:1,VariableDeclarator:1}]}}]}async function h(){return[{name:`${t}:old_config`,languageOptions:{globals:{...s.browser,...s.jquery,...s.node,document:"readonly",navigator:"readonly",window:"readonly"}},ignores:["**/.next/*","**/node_modules/*","**/.github/*","cypress","**/__tests__/e2e/*","*.json","**/*.d.ts",".eslintrc.js","eslint.config.js",".prettierrc",".stylelintrc.js","tsconfig.json","package.json","*.md","*.config.ts","*.config.js","*.md"]},{name:`${t}:rules_breakup_1`,rules:{"@next/next/no-duplicate-head":"off"}},{name:`${t}:rules_breakup_2`,rules:{"style/operator-linebreak":"off","test/consistent-test-it":"off","test/prefer-lowercase-title":"off","style/jsx-quotes":"off","style/multiline-ternary":"off","style/indent":"off"},ignores:["cypress"]},{name:`${t}:prettier`,rules:{"antfu/if-newline":"off"}}]}async function j(){return[l]}async function _(e,r){return[{name:"Deprecation plugin",languageOptions:{parserOptions:{project:r?.tsconfigPath??"./tsconfig.json",projectSource:!0}},plugins:{deprecation:u(m)},rules:{"deprecation/deprecation":e},files:["**/*.ts","**/*.tsx"]}]}function b(e,...r){const n=[];return e={...e,react:o(!0,e?.react),vue:o(!1,e?.vue),jsonc:o(!1,e?.jsonc),yaml:o(!1,e?.yaml),stylistic:o({semi:!0,quotes:"single"},e?.stylistic),typescript:o({overrides:{"ts/consistent-type-definitions":["error","interface"],"ts/interface-name-prefix":"off","ts/explicit-function-return-type":"off","ts/explicit-module-boundary-types":"off","ts/no-explicit-any":"off"}},e?.typescript),rules:o({"import/order":"off","react/react-in-jsx-scope":"off","react/prop-types":"off","antfu/top-level-function":"off","perfectionist/sort-imports":"off","perfectionist/sort-named-imports":"off","perfectionist/sort-named-exports":"off","antfu/consistent-chaining":"off","perfectionist/sort-exports":"off","style/no-multiple-empty-lines":"off"},e?.rules),deprecation:e?.deprecation,tsconfigPath:e?.tsconfigPath},(e.react??!0)&&n.push(x()),(e.all??!0)&&n.push(w()),(e.next??!1)&&n.push(y()),(e.markdown??!0)&&n.push(g()),e?.deprecation&&n.push(_(e?.deprecation??"warn",{tsconfigPath:e?.tsconfigPath})),n.push(h()),n.push(j()),c(e,...n,...r)}export{b as default};

package/next/index.mjs

@@ -1,11 +0,0 @@
-import r from"next/script";const n=()=>React.createElement("script",{src:"https://unpkg.com/react-scan/dist/auto.global.js",async:!0}),i=({id:t,clickMap:e=!0,trackLinks:a=!0,accurateTrackBounce:c=!0})=>React.createElement(r,{id:"metrika-counter",strategy:"afterInteractive"},`   (function(m,e,t,r,i,k,a){m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)};
-           m[i].l=1*new Date();
-           for (var j = 0; j < document.scripts.length; j++) {if (document.scripts[j].src === r) { return; }}
-           k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a)})
-           (window, document, "script", "https://mc.yandex.ru/metrika/tag.js", "ym");
-        
-           ym(${t}, "init", {
-                clickmap:${e},
-                trackLinks:${a},
-                accurateTrackBounce:${c}
-           });`);export{i as Metrika,n as ReactScan};

package/vitest/index.mjs

@@ -1 +0,0 @@
-import{expect as c,vi as t,afterEach as f,beforeAll as u,afterAll as h}from"vitest";import{render as d,renderHook as m}from"@testing-library/react";import l from"ansi-colors";import p from"vitest-matchmedia-mock";const a=e=>{c(()=>e()).not.toThrow()},b=(...e)=>{a(()=>d(...e))},C=(...e)=>{a(()=>m(...e))},k=e=>{t.stubEnv("CANONICAL_URL","http://localhost:4242"),t.stubEnv("IS_PRODUCTION","false"),e&&Object.entries(e).forEach(([o,n])=>t.stubEnv(o,n))},r=()=>{t.clearAllMocks(),t.resetAllMocks(),t.unstubAllEnvs(),t.unstubAllGlobals()},x=()=>{t.mock("next/navigation",()=>({useRouter:()=>({push(){}}),usePathname:()=>"/"}))},A={addBase:t.fn(),addComponents:t.fn(),addUtilities:t.fn(),addVariant:t.fn(),config:t.fn(),corePlugins:t.fn(),e:t.fn(),matchComponents:t.fn(),matchUtilities:t.fn(),matchVariant:t.fn(),theme:t.fn()};class g{_executionContext;constructor(o){this._executionContext=o}call(...o){console.debug(`${l.blue(`[${this._executionContext}]`)} ${l.green(`Custom spy is called with these args: ${l.blueBright(o.map(n=>`${n}`).join(", "))}`)}`)}}function v(e){const o=new g(e),n=t.spyOn(o,"call");return{expectToBeCalled:(...s)=>c(n).toHaveBeenCalledWith(s),expectToBeNotCalled:(...s)=>c(n).not.toHaveBeenCalledWith(s),spy:n,callSpy:(...s)=>o.call(s)}}const E=(e,o)=>{t.stubGlobal(e,o)},M={beforeAll:u,afterEach:f},i=(e,o="beforeAll")=>{let n;M[o](()=>n=e()),h(()=>{r(),n?.()})},y=()=>{const e=new p;i(()=>(e.clear(),()=>e.destroy()),"afterEach")};export{C as assertHookRendering,a as assertNotThrowing,b as assertRendering,r as clearMocks,y as injectMatchMediaMock,i as injectMocks,k as mockEnv,x as mockRouter,v as spyFactory,E as stubGlobal,A as twApiMock};