Merge pull request #253 from vim-denops/unknownutil-v4

📦 Update unknownutil v4

Author: lambdalisue

buffer/buffer.ts

@@ -1,5 +1,5 @@
 import type { Denops } from "@denops/core";
-import { maybe } from "@core/unknownutil";
+import { maybe } from "@core/unknownutil/maybe";
 import { ulid } from "@std/ulid";
 import * as autocmd from "../autocmd/mod.ts";
 import * as batch from "../batch/mod.ts";

buffer/fileformat.ts

@@ -1,38 +1,15 @@
-import { assert, ensure, is, maybe, type Predicate } from "@core/unknownutil";
+import type { Predicate } from "@core/unknownutil/type";
+import { isLiteralOneOf } from "@core/unknownutil/is/literal-one-of";
 
 export type FileFormat = "unix" | "dos" | "mac";
 
 /**
  * Predicate that the value is FileFormat.
  */
-export const isFileFormat: Predicate<FileFormat> = is.LiteralOneOf(
+export const isFileFormat: Predicate<FileFormat> = isLiteralOneOf(
   ["unix", "dos", "mac"] as const,
 );
 
-/**
- * Assert that the value is FileFormat.
- *
- * @deprecated Use `assert` function of `unknownutil` instead.
- */
-export const assertFileFormat = (v: unknown): asserts v is FileFormat =>
-  assert(v, isFileFormat);
-
-/**
- * Ensure that the value is FileFormat.
- *
- * @deprecated Use `ensure` function of `unknownutil` instead.
- */
-export const ensureFileFormat = (v: unknown): FileFormat =>
-  ensure(v, isFileFormat);
-
-/**
- * Maybe that the value is FileFormat.
- *
- * @deprecated Use `maybe` function of `unknownutil` instead.
- */
-export const maybeFileFormat = (v: unknown): FileFormat | undefined =>
-  maybe(v, isFileFormat);
-
 const fileFormatDelimiters = {
   unix: "\n",
   dos: "\r\n",

buffer/mod.ts

@@ -54,10 +54,5 @@
  */
 export * from "./buffer.ts";
 export * from "./decoration.ts";
-export {
-  assertFileFormat,
-  ensureFileFormat,
-  isFileFormat,
-  maybeFileFormat,
-} from "./fileformat.ts";
+export { isFileFormat } from "./fileformat.ts";
 export type { FileFormat } from "./fileformat.ts";

deno.jsonc

@@ -41,7 +41,7 @@
     ]
   },
   "imports": {
-    "@core/unknownutil": "jsr:@core/unknownutil@^3.18.0",
+    "@core/unknownutil": "jsr:@core/unknownutil@^4.0.0",
     "@denops/core": "jsr:@denops/core@^7.0.0",
     "@denops/test": "jsr:@denops/test@^3.0.1",
     "@lambdalisue/errorutil": "jsr:@lambdalisue/errorutil@^1.0.0",

function/types.ts

@@ -1,4 +1,8 @@
-import { assert, is } from "@core/unknownutil";
+import { assert } from "@core/unknownutil/assert";
+import { isNumber } from "@core/unknownutil/is/number";
+import { isObjectOf } from "@core/unknownutil/is/object-of";
+import { isTupleOf } from "@core/unknownutil/is/tuple-of";
+import { isUnionOf } from "@core/unknownutil/is/union-of";
 
 /**
  * Type of `screenpos()` result.
@@ -15,12 +19,12 @@ export type ScreenPos = {
  */
 export function isScreenPos(x: unknown): x is ScreenPos {
   const predObj = {
-    row: is.Number,
-    col: is.Number,
-    endcol: is.Number,
-    curscol: is.Number,
+    row: isNumber,
+    col: isNumber,
+    endcol: isNumber,
+    curscol: isNumber,
   };
-  return is.ObjectOf(predObj)(x);
+  return isObjectOf(predObj)(x);
 }
 
 /**
@@ -45,9 +49,9 @@ export type Position = [
  * Return true if the value is Position.
  */
 export function isPosition(x: unknown): x is Position {
-  const pred = is.OneOf([
-    is.TupleOf([is.Number, is.Number, is.Number, is.Number]),
-    is.TupleOf([is.Number, is.Number, is.Number, is.Number, is.Number]),
+  const pred = isUnionOf([
+    isTupleOf([isNumber, isNumber, isNumber, isNumber]),
+    isTupleOf([isNumber, isNumber, isNumber, isNumber, isNumber]),
   ]);
   return pred(x);
 }

helper/expr_string.ts

@@ -25,7 +25,18 @@
  * @module
  */
 import type { Context, Denops, Dispatcher, Meta } from "@denops/core";
-import { is } from "@core/unknownutil";
+import { isArray } from "@core/unknownutil/is/array";
+import { isBoolean } from "@core/unknownutil/is/boolean";
+import { isFunction } from "@core/unknownutil/is/function";
+import { isInstanceOf } from "@core/unknownutil/is/instance-of";
+import { isLiteralOf } from "@core/unknownutil/is/literal-of";
+import { isNullish } from "@core/unknownutil/is/nullish";
+import { isNumber } from "@core/unknownutil/is/number";
+import { isObjectOf } from "@core/unknownutil/is/object-of";
+import { isRecord } from "@core/unknownutil/is/record";
+import { isString } from "@core/unknownutil/is/string";
+import { isSymbol } from "@core/unknownutil/is/symbol";
+import { isUndefined } from "@core/unknownutil/is/undefined";
 import { ulid } from "@std/ulid";
 import { execute } from "./execute.ts";
 
@@ -55,7 +66,7 @@ type TemplateSubstitutions = any[];
 const cacheKey = "denops_std/helper/expr_string@1";
 
 async function ensurePrerequisites(denops: Denops): Promise<string> {
-  if (is.String(denops.context[cacheKey])) {
+  if (isString(denops.context[cacheKey])) {
     return denops.context[cacheKey];
   }
   const suffix = ulid();
@@ -95,9 +106,9 @@ export function exprQuote(
   });
 }
 
-const isInstanceOfBoolean = is.InstanceOf(Boolean);
-const isInstanceOfNumber = is.InstanceOf(Number);
-const isInstanceOfString = is.InstanceOf(String);
+const isInstanceOfBoolean = isInstanceOf(Boolean);
+const isInstanceOfNumber = isInstanceOf(Number);
+const isInstanceOfString = isInstanceOf(String);
 
 /**
  * Returns `true` if the value is a string marked as Vim's string constant format.
@@ -110,17 +121,17 @@ const isInstanceOfString = is.InstanceOf(String);
  * ```
  */
 export function isExprString(x: unknown): x is ExprString {
-  return is.ObjectOf({
-    [EXPR_STRING_MARK]: is.LiteralOf(1),
+  return isObjectOf({
+    [EXPR_STRING_MARK]: isLiteralOf(1),
   })(x);
 }
 
 function isJsonable(x: unknown): x is Jsonable {
-  return x != null && is.Function((x as Jsonable).toJSON);
+  return x != null && isFunction((x as Jsonable).toJSON);
 }
 
 function isIgnoreRecordValue(x: unknown): boolean {
-  return is.Undefined(x) || is.Function(x) || is.Symbol(x);
+  return isUndefined(x) || isFunction(x) || isSymbol(x);
 }
 
 /**
@@ -134,26 +145,26 @@ export function vimStringify(value: unknown, key?: string | number): string {
     // Return Vim's expr-string
     return `"${value.replaceAll('"', '\\"')}"`;
   }
-  if ((is.Nullish(value) || is.Function(value) || is.Symbol(value))) {
+  if ((isNullish(value) || isFunction(value) || isSymbol(value))) {
     return "v:null";
   }
-  if (is.Boolean(value) || isInstanceOfBoolean(value)) {
+  if (isBoolean(value) || isInstanceOfBoolean(value)) {
     // Return v:true or v:false
     return `v:${value}`;
   }
-  if (is.Number(value) || isInstanceOfNumber(value)) {
+  if (isNumber(value) || isInstanceOfNumber(value)) {
     // Replace `5e-10` to `5.0e-10`
     return `${value}`.replace(/^(\d+)e/, "$1.0e");
   }
-  if (is.String(value) || isInstanceOfString(value)) {
+  if (isString(value) || isInstanceOfString(value)) {
     // Returns Vim's literal-string
     return `'${value.replaceAll("'", "''")}'`;
   }
-  if (is.Array(value)) {
+  if (isArray(value)) {
     // Returns Vim's list
     return `[${value.map(vimStringify).join(",")}]`;
   }
-  if (is.Record(value)) {
+  if (isRecord(value)) {
     // Returns Vim's dict
     return `{${
       Object.entries(value)
@@ -169,7 +180,7 @@ export function vimStringify(value: unknown, key?: string | number): string {
 }
 
 function trimEndOfArgs(args: unknown[]): unknown[] {
-  const last = args.findIndex(is.Undefined);
+  const last = args.findIndex(isUndefined);
   return last < 0 ? args : args.slice(0, last);
 }
 

helper/input.ts

@@ -1,5 +1,7 @@
 import type { Denops } from "@denops/core";
-import { assert, is } from "@core/unknownutil";
+import { assert } from "@core/unknownutil/assert";
+import { isNumber } from "@core/unknownutil/is/number";
+import { isString } from "@core/unknownutil/is/string";
 import { ulid } from "@std/ulid";
 import * as fn from "../function/mod.ts";
 import * as lambda from "../lambda/mod.ts";
@@ -218,9 +220,9 @@ export async function input(
   const completion = options.completion ?? null;
   if (completion && typeof completion !== "string") {
     const id = lambda.register(denops, async (arglead, cmdline, cursorpos) => {
-      assert(arglead, is.String);
-      assert(cmdline, is.String);
-      assert(cursorpos, is.Number);
+      assert(arglead, isString);
+      assert(cmdline, isString);
+      assert(cursorpos, isNumber);
       return await completion(arglead, cmdline, cursorpos);
     });
     try {

helper/keymap.ts

@@ -1,5 +1,6 @@
 import type { Denops } from "@denops/core";
-import { is } from "@core/unknownutil";
+import { isArray } from "@core/unknownutil/is/array";
+import { isString } from "@core/unknownutil/is/string";
 import {
   exprQuote as q,
   type ExprString,
@@ -18,11 +19,11 @@ export type Keys = {
 export type KeysSpecifier = Keys | Keys["keys"];
 
 function toArray<T>(x: T | T[]): T[] {
-  return is.Array(x) ? x : [x];
+  return isArray(x) ? x : [x];
 }
 
 function toKeys(keys: KeysSpecifier): Keys {
-  if (is.String(keys) || isExprString(keys)) {
+  if (isString(keys) || isExprString(keys)) {
     return { keys, remap: false };
   }
   return keys;