@skbkontur/react-ui 5.6.7 → 5.6.9-5e213.0

package/cjs/components/MaskedInput/react-imask/imask/masked/factory.js

@@ -0,0 +1,218 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;Object.defineProperty(exports, "__esModule", { value: true });exports.createMask = createMask;exports.maskedClass = maskedClass;exports.normalizeOpts = normalizeOpts;var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));var _utils = require("../core/utils");
+
+var _base = require("./base");
+var _pattern = require("./pattern");
+var _regexp = require("./regexp");var _excluded = ["mask"];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** Get Masked class by mask type */
+function maskedClass(
+mask)
+{
+  // eslint-disable-next-line eqeqeq
+  if (mask == null) {
+    throw new Error('mask property should be defined');
+  }
+
+  if (mask instanceof RegExp) {
+    return _regexp.MaskedRegExp;
+  }
+  if ((0, _utils.isString)(mask)) {
+    return _pattern.MaskedPattern;
+  }
+  if (mask.prototype instanceof _base.Masked) {
+    return mask;
+  }
+  if (mask instanceof _base.Masked) {
+    return mask.constructor;
+  }
+
+  console.warn('Mask not found for mask', mask);
+  return _base.Masked;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function normalizeOpts(opts) {
+  if (!opts) {
+    throw new Error('Options in not defined');
+  }
+
+  if (typeof opts === 'function' && opts.prototype instanceof _base.Masked) {
+    return { mask: opts };
+  }
+
+  /*
+    handle cases like:
+    1) opts = Masked
+    2) opts = { mask: Masked, ...instanceOpts }
+  */
+  var _ref =
+    // eslint-disable-next-line no-nested-ternary
+    opts instanceof _base.Masked ?
+    { mask: opts } :
+    (0, _utils.isObject)(opts) && opts.mask instanceof _base.Masked ?
+    opts :
+    {},_ref$mask = _ref.mask,mask = _ref$mask === void 0 ? undefined : _ref$mask,instanceOpts = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+
+  if (mask) {
+    var _mask = mask.mask;
+
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({},
+    (0, _utils.pick)(mask, function (_, k) {return !k.startsWith('_');})), {}, {
+      mask: mask.constructor,
+      _mask: _mask },
+    instanceOpts);
+
+  }
+
+  if (!(0, _utils.isObject)(opts)) {
+    return { mask: opts };
+  }
+
+  return (0, _objectSpread2.default)({}, opts);
+}
+
+/** Creates new {@link Masked} depending on mask type */
+function createMask(opts) {
+  if (opts instanceof _base.Masked) {
+    return opts;
+  }
+  var nOpts = normalizeOpts(opts);
+
+  var MaskedClass = maskedClass(nOpts.mask);
+  if (!MaskedClass) {
+    throw new Error("Masked class is not found for provided mask ".concat(
+      nOpts.mask, ", appropriate module needs to be imported manually before creating mask.")
+    );
+  }
+
+  if (nOpts.mask === MaskedClass) {
+    delete nOpts.mask;
+  }
+  var nOptsWithInternal = nOpts;
+  if (nOptsWithInternal._mask !== undefined && nOptsWithInternal._mask !== null) {
+    nOptsWithInternal.mask = nOptsWithInternal._mask;
+    delete nOptsWithInternal._mask;
+  }
+  return new MaskedClass(nOpts);
+}

package/cjs/components/MaskedInput/react-imask/imask/masked/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_utils","require","_base","_pattern","_regexp","_excluded","maskedClass","mask","Error","RegExp","MaskedRegExp","isString","MaskedPattern","prototype","Masked","constructor","console","warn","normalizeOpts","opts","_ref","isObject","_ref$mask","undefined","instanceOpts","_objectWithoutProperties2","default","_mask","_objectSpread2","pick","_","k","startsWith","createMask","nOpts","MaskedClass","concat","nOptsWithInternal"],"sources":["factory.ts"],"sourcesContent":["import { isString, pick, isObject } from '../core/utils';\n\nimport { Masked, type MaskedOptions } from './base';\nimport { MaskedPattern, type MaskedPatternOptions } from './pattern';\nimport { MaskedRegExp, type MaskedRegExpOptions } from './regexp';\n\nexport type FactoryStaticOpts = MaskedPatternOptions | MaskedRegExpOptions;\n\nexport type AllFactoryStaticOpts = MaskedPatternOptions & MaskedRegExpOptions;\n\nexport type FactoryStaticReturnMasked<Opts extends FactoryStaticOpts> = Opts extends MaskedPatternOptions\n  ? MaskedPattern\n  : Opts extends MaskedRegExpOptions\n    ? MaskedRegExp\n    : never;\n\nexport type FactoryStaticMaskReturnMasked<Mask extends FactoryStaticOpts['mask']> =\n  Mask extends MaskedPatternOptions['mask']\n    ? MaskedPattern\n    : Mask extends MaskedRegExpOptions['mask']\n      ? MaskedRegExp\n      : never;\n\nexport type FactoryInstanceOpts =\n  | ({ mask: MaskedRegExp } & Omit<MaskedRegExpOptions, 'mask'>)\n  | ({ mask: MaskedPattern } & Omit<MaskedPatternOptions, 'mask'>)\n  | ({ mask: Masked } & Omit<MaskedOptions, 'mask'>);\n\nexport type FactoryInstanceReturnMasked<Opts extends FactoryInstanceOpts> = Opts extends { mask: infer M } ? M : never;\n\nexport type FactoryConstructorOpts =\n  | ({ mask: typeof MaskedRegExp } & Omit<MaskedRegExpOptions, 'mask'>)\n  | ({ mask: typeof MaskedPattern } & Omit<MaskedPatternOptions, 'mask'>)\n  | ({ mask: typeof Masked } & Omit<MaskedOptions, 'mask'>);\n\nexport type FactoryConstructorReturnMasked<Opts extends FactoryConstructorOpts> = Opts extends {\n  mask: typeof MaskedRegExp;\n}\n  ? MaskedRegExp\n  : Opts extends { mask: typeof MaskedPattern }\n    ? MaskedPattern\n    : Masked;\n\nexport type FactoryOpts = FactoryConstructorOpts | FactoryInstanceOpts | FactoryStaticOpts;\n\nexport type FactoryArg = Masked | FactoryOpts | FactoryStaticOpts['mask'];\n\nexport type ExtendFactoryArgOptions<Opts extends { [key: string]: any }> =\n  | Masked\n  | (FactoryOpts & Opts)\n  | FactoryStaticOpts['mask'];\n\nexport type UpdateStaticOpts<Opts extends FactoryStaticOpts> = Opts extends MaskedPatternOptions\n  ? MaskedPatternOptions\n  : Opts extends MaskedRegExpOptions\n    ? MaskedRegExpOptions\n    : never;\n\ntype AnyOpts = Record<string, any>;\n\nexport type UpdateInstanceOpts<M extends Masked> = M extends MaskedRegExp\n  ? MaskedRegExpOptions\n  : M extends MaskedPattern\n    ? MaskedPatternOptions\n    : AnyOpts;\n\nexport type UpdateConstructorOpts<M extends FactoryConstructorOpts> = M extends { mask: typeof MaskedRegExp }\n  ? MaskedRegExpOptions\n  : M extends { mask: typeof MaskedPattern }\n    ? MaskedPatternOptions\n    : AnyOpts;\n\nexport type UpdateStaticMaskOpts<M extends FactoryStaticOpts['mask']> = M extends MaskedPatternOptions['mask']\n  ? MaskedPatternOptions\n  : M extends MaskedRegExpOptions['mask']\n    ? MaskedRegExpOptions\n    : never;\n\nexport type UpdateOpts<Opts extends FactoryArg> = Partial<\n  Opts extends Masked\n    ? UpdateInstanceOpts<Opts>\n    : Opts extends FactoryStaticOpts['mask']\n      ? UpdateStaticMaskOpts<Opts>\n      : Opts extends FactoryStaticOpts\n        ? UpdateStaticOpts<Opts>\n        : Opts extends FactoryInstanceOpts\n          ? UpdateInstanceOpts<Opts['mask']>\n          : Opts extends FactoryConstructorOpts\n            ? UpdateConstructorOpts<Opts>\n            : AnyOpts\n>;\n\nexport type FactoryReturnMasked<Opts extends FactoryArg> = Opts extends Masked\n  ? Opts\n  : Opts extends FactoryStaticOpts['mask']\n    ? FactoryStaticMaskReturnMasked<Opts>\n    : Opts extends FactoryConstructorOpts\n      ? FactoryConstructorReturnMasked<Opts>\n      : Opts extends FactoryInstanceOpts\n        ? FactoryInstanceReturnMasked<Opts>\n        : Opts extends FactoryStaticOpts\n          ? FactoryStaticReturnMasked<Opts>\n          : never;\n\n/** Get Masked class by mask type */\nexport function maskedClass(\n  mask: Masked | FactoryOpts['mask'],\n): typeof MaskedPattern | typeof MaskedRegExp | typeof Masked {\n  // eslint-disable-next-line eqeqeq\n  if (mask == null) {\n    throw new Error('mask property should be defined');\n  }\n\n  if (mask instanceof RegExp) {\n    return MaskedRegExp;\n  }\n  if (isString(mask)) {\n    return MaskedPattern;\n  }\n  if ((mask as { prototype?: unknown }).prototype instanceof Masked) {\n    return mask as typeof MaskedPattern | typeof MaskedRegExp | typeof Masked;\n  }\n  if (mask instanceof Masked) {\n    return mask.constructor as typeof MaskedPattern | typeof MaskedRegExp | typeof Masked;\n  }\n\n  console.warn('Mask not found for mask', mask);\n  return Masked;\n}\n\ntype MaskedClassOf<M extends Masked> = M extends MaskedRegExp\n  ? typeof MaskedRegExp\n  : M extends MaskedPattern\n    ? typeof MaskedPattern\n    : any;\n\ntype NormalizedMaskedOpts<Opts extends Masked> = Omit<Opts, 'mask'> & {\n  _mask: Opts;\n  mask: MaskedClassOf<Opts>;\n};\n\ntype NormalizedInstanceOpts<Opts extends FactoryInstanceOpts> = Omit<Opts['mask'], `_${string}` | 'mask'> &\n  NormalizedMaskedOpts<Opts['mask']>;\n\nexport type NormalizedOpts<Opts extends FactoryArg> = Opts extends FactoryStaticOpts['mask']\n  ? { mask: Opts }\n  : Opts extends Masked\n    ? NormalizedMaskedOpts<Opts>\n    : Opts extends FactoryInstanceOpts\n      ? NormalizedInstanceOpts<Opts>\n      : Opts extends FactoryStaticOpts | FactoryConstructorOpts\n        ? Opts\n        : { mask: Opts };\n\nexport function normalizeOpts<Opts extends FactoryArg>(opts: Opts): NormalizedOpts<Opts> {\n  if (!opts) {\n    throw new Error('Options in not defined');\n  }\n\n  if (typeof opts === 'function' && (opts as { prototype?: unknown }).prototype instanceof Masked) {\n    return { mask: opts } as unknown as NormalizedOpts<Opts>;\n  }\n\n  /*\n    handle cases like:\n    1) opts = Masked\n    2) opts = { mask: Masked, ...instanceOpts }\n  */\n  const { mask = undefined, ...instanceOpts } =\n    // eslint-disable-next-line no-nested-ternary\n    opts instanceof Masked\n      ? { mask: opts }\n      : isObject(opts) && (opts as FactoryInstanceOpts).mask instanceof Masked\n        ? (opts as FactoryInstanceOpts)\n        : {};\n\n  if (mask) {\n    const _mask = (mask as Masked).mask;\n\n    return {\n      ...pick(mask, (_, k: string) => !k.startsWith('_')),\n      mask: mask.constructor,\n      _mask,\n      ...instanceOpts,\n    } as NormalizedOpts<Opts>;\n  }\n\n  if (!isObject(opts)) {\n    return { mask: opts } as unknown as NormalizedOpts<Opts>;\n  }\n\n  return { ...opts } as unknown as NormalizedOpts<Opts>;\n}\n\n/** Creates new {@link Masked} depending on mask type */\nexport function createMask<Opts extends FactoryArg>(opts: Opts): FactoryReturnMasked<Opts> {\n  if (opts instanceof Masked) {\n    return opts as FactoryReturnMasked<Opts>;\n  }\n  const nOpts = normalizeOpts(opts);\n\n  const MaskedClass = maskedClass(nOpts.mask);\n  if (!MaskedClass) {\n    throw new Error(\n      `Masked class is not found for provided mask ${nOpts.mask}, appropriate module needs to be imported manually before creating mask.`,\n    );\n  }\n\n  if (nOpts.mask === MaskedClass) {\n    delete nOpts.mask;\n  }\n  const nOptsWithInternal = nOpts as NormalizedOpts<Opts> & { _mask?: unknown };\n  if (nOptsWithInternal._mask !== undefined && nOptsWithInternal._mask !== null) {\n    nOptsWithInternal.mask = nOptsWithInternal._mask as NormalizedOpts<Opts>['mask'];\n    delete nOptsWithInternal._mask;\n  }\n  return new (MaskedClass as unknown as new (opts: unknown) => FactoryReturnMasked<Opts>)(nOpts);\n}\n"],"mappings":"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","ignoreList":[]}

package/cjs/components/MaskedInput/react-imask/imask/masked/pattern.d.ts

@@ -0,0 +1,101 @@
+import { ChangeDetails } from '../core/change-details';
+import { type TailDetails } from '../core/tail-details';
+import { type Direction } from '../core/utils';
+import { Masked, type AppendFlags, type ExtractFlags, type MaskedOptions, type MaskedState } from './base';
+import { type FactoryArg, type ExtendFactoryArgOptions } from './factory';
+import type { PatternBlock } from './patterns/block';
+import { PatternFixedDefinition } from './patterns/fixed-definition';
+import { PatternInputDefinition } from './patterns/input-definition';
+import './regexp';
+export type MaskedPatternOptions<Value = string, M extends MaskedPattern<Value> = MaskedPattern<Value>, Props extends keyof M = never> = MaskedOptions<M, 'definitions' | 'blocks' | 'placeholderChar' | 'displayChar' | 'lazy' | Props>;
+export interface Definitions {
+    [k: string]: FactoryArg;
+}
+export type MaskedPatternState = MaskedState & {
+    _blocks: MaskedState[];
+};
+export interface BlockPosData {
+    index: number;
+    offset: number;
+}
+export interface BlockExtraOptions {
+    expose?: boolean;
+}
+/** Pattern mask */
+export declare class MaskedPattern<Value = string> extends Masked<Value> {
+    static DEFAULTS: {
+        lazy: boolean;
+        placeholderChar: string;
+        skipInvalid?: boolean | undefined;
+    };
+    static STOP_CHAR: string;
+    static ESCAPE_CHAR: string;
+    static InputDefinition: typeof PatternInputDefinition;
+    static FixedDefinition: typeof PatternFixedDefinition;
+    mask: string;
+    /** */
+    blocks: {
+        [key: string]: ExtendFactoryArgOptions<BlockExtraOptions>;
+    };
+    /** */
+    definitions: Definitions;
+    /** Single char for empty input */
+    placeholderChar: string;
+    /** Single char for filled input */
+    displayChar: string;
+    /** Show placeholder only when needed */
+    lazy: boolean;
+    /** Enable characters overwriting */
+    overwrite?: boolean | 'shift' | undefined;
+    /** */
+    eager?: boolean | 'remove' | 'append' | undefined;
+    /** */
+    skipInvalid?: boolean | undefined;
+    /** */
+    autofix?: boolean | 'pad' | undefined;
+    _blocks: PatternBlock[];
+    _maskedBlocks: {
+        [key: string]: number[];
+    };
+    _stops: number[];
+    exposeBlock?: Masked;
+    constructor(opts: MaskedPatternOptions<Value>);
+    updateOptions(opts: Partial<MaskedPatternOptions<Value>>): void;
+    _update(opts: Partial<MaskedPatternOptions<Value>>): void;
+    _rebuildMask(): void;
+    get state(): MaskedPatternState;
+    set state(state: MaskedPatternState);
+    reset(): void;
+    get isComplete(): boolean;
+    get isFilled(): boolean;
+    get isFixed(): boolean;
+    get isOptional(): boolean;
+    doCommit(): void;
+    get unmaskedValue(): string;
+    set unmaskedValue(unmaskedValue: string);
+    get value(): string;
+    set value(value: string);
+    get typedValue(): Value;
+    set typedValue(value: Value);
+    get displayValue(): string;
+    appendTail(tail: string | TailDetails): ChangeDetails;
+    _appendEager(): ChangeDetails;
+    _appendCharRaw(ch: string, flags?: AppendFlags<MaskedPatternState>): ChangeDetails;
+    extractTail(fromPos?: number, toPos?: number): TailDetails;
+    extractInput(fromPos?: number, toPos?: number, flags?: ExtractFlags): string;
+    _findStopBefore(blockIndex: number): number | undefined;
+    /** Appends placeholder depending on laziness */
+    _appendPlaceholder(toBlockIndex?: number): ChangeDetails;
+    /** Finds block in pos */
+    _mapPosToBlock(pos: number): BlockPosData | undefined;
+    _blockStartPos(blockIndex: number): number;
+    _forEachBlocksInRange(fromPos: number, toPos: number | undefined, fn: (block: PatternBlock, blockIndex: number, fromPos: number, toPos: number) => void): void;
+    remove(fromPos?: number, toPos?: number): ChangeDetails;
+    nearestInputPos(cursorPos: number, direction?: Direction): number;
+    totalInputPositions(fromPos?: number, toPos?: number): number;
+    /** Get block by name */
+    maskedBlock(name: string): PatternBlock | undefined;
+    /** Get all blocks by name */
+    maskedBlocks(name: string): PatternBlock[];
+    pad(flags?: AppendFlags): ChangeDetails;
+}