TypeScript Type.isObject方法代碼示例

 const handler = (value: string, meta?: Record<string, any>) => {
   if (!Type.isString(value)) {
     throw new Error('Expected value to be string');
   }
   if (meta !== undefined && !Type.isObject(meta)) {
     throw new Error('Expected meta to be a object');
   }
   const r: UrlData = { value, meta };
   completer(r);
 };

const items = (value: boolean | string, defaultValue: string): string => {

  if (Type.isArray(value) || Type.isObject(value)) {
    throw new Error('expected a string but found: ' + value);
  }

  if (Type.isUndefined(value)) {
    return defaultValue;
  }

  if (Type.isBoolean(value)) {
    return value === false ? '' : defaultValue;
  }
  return value;
};

  const create = function (o: BlobInfoData | string, blob?: Blob, base64?: string, filename?: string): BlobInfo {
    if (Type.isString(o)) {
      const id = o as string;

      return toBlobInfo({
        id,
        name: filename,
        blob,
        base64
      });
    } else if (Type.isObject(o)) {
      return toBlobInfo(o);
    } else {
      throw new Error('Unknown input type');
    }
  };

const isRaw = (str: any): str is RawString => Type.isObject(str) && Obj.has(str, 'raw');

const isRecordOfUrlArray = (r: any): boolean => {
  return Type.isObject(r) && Obj.find(r, (value) => !isArrayOfUrl(value)).isNone();
};

const normalizePattern = (pattern: RawPattern): Result<Pattern, PatternError> => {
  const err = (message: string) => Result.error({ message, pattern });
  const formatOrCmd = <T> (name: string, onFormat: (formats: string[]) => T, onCommand: (cmd: string, value: any) => T): Result<T, PatternError> => {
    if (pattern.format !== undefined) {
      let formats: string[];
      if (Type.isArray(pattern.format)) {
        if (!Arr.forall(pattern.format, Type.isString)) {
          return err(name + ' pattern has non-string items in the `format` array');
        }
        formats = pattern.format;
      } else if (Type.isString(pattern.format)) {
        formats = [pattern.format];
      } else {
        return err(name + ' pattern has non-string `format` parameter');
      }
      return Result.value(onFormat(formats));
    } else if (pattern.cmd !== undefined) {
      if (!Type.isString(pattern.cmd)) {
        return err(name + ' pattern has non-string `cmd` parameter');
      }
      return Result.value(onCommand(pattern.cmd, pattern.value));
    } else {
      return err(name + ' pattern is missing both `format` and `cmd` parameters');
    }
  };
  if (!Type.isObject(pattern)) {
    return err('Raw pattern is not an object');
  }
  if (!Type.isString(pattern.start)) {
    return err('Raw pattern is missing `start` parameter');
  }
  if (pattern.end !== undefined) {
    // inline pattern
    if (!Type.isString(pattern.end)) {
      return err('Inline pattern has non-string `end` parameter');
    }
    if (pattern.start.length === 0 && pattern.end.length === 0) {
      return err('Inline pattern has empty `start` and `end` parameters');
    }
    let start = pattern.start;
    let end = pattern.end;
    // when the end is empty swap with start as it is more efficent
    if (end.length === 0) {
      end = start;
      start = '';
    }
    return formatOrCmd<InlinePattern>('Inline',
    (format) => ({ type: 'inline-format', start, end, format }),
    (cmd, value) => ({ type: 'inline-command', start, end, cmd, value }));
  } else if (pattern.replacement !== undefined) {
    // replacement pattern
    if (!Type.isString(pattern.replacement)) {
      return err('Replacement pattern has non-string `replacement` parameter');
    }
    if (pattern.start.length === 0) {
      return err('Replacement pattern has empty `start` parameter');
    }
    return Result.value<InlineCmdPattern>({
      type: 'inline-command',
      start: '',
      end: pattern.start,
      cmd: 'mceInsertContent',
      value: pattern.replacement,
    });
  } else {
    // block pattern
    if (pattern.start.length === 0) {
      return err('Block pattern has empty `start` parameter');
    }
    return formatOrCmd<BlockPattern>('Block', (formats) => ({
      type: 'block-format',
      start: pattern.start,
      format: formats[0]
    }), (command, commandValue) => ({
      type: 'block-command',
      start: pattern.start,
      cmd: command,
      value: commandValue,
    }));
  }
};

const isCustomMessage = (data: any): boolean => {
  return !isSupportedMessage(data) && Type.isObject(data) && Obj.has(data, 'mceAction');
};