First impl

Author: lambdalisue

.github/workflows/test.yml

@@ -0,0 +1,59 @@
+name: Test
+
+env:
+  DENO_VERSION: 1.x
+
+on:
+  schedule:
+    - cron: "0 7 * * 0"
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: denoland/setup-deno@main
+        with:
+          deno-version: ${{ env.DENO_VERSION }}
+      - name: Lint
+        run: deno lint
+
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: denoland/setup-deno@main
+        with:
+          deno-version: ${{ env.DENO_VERSION }}
+      - name: Format
+        run: |
+          deno fmt --check
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: denoland/setup-deno@main
+        with:
+          deno-version: ${{ env.DENO_VERSION }}
+      - name: Test
+        run: |
+          deno test
+        timeout-minutes: 5
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: denoland/setup-deno@main
+        with:
+          deno-version: ${{ env.DENO_VERSION }}
+      - name: Type check
+        run: |
+          deno test --unstable --no-run ./*.ts

LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Alisue, hashnote.net
+
+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.
+

README.md

@@ -0,0 +1,99 @@
+# unknownutil-deno
+
+[![deno land](http://img.shields.io/badge/available%20on-deno.land/x-lightgrey.svg?logo=deno)](https://deno.land/x/unknownutil)
+[![deno doc](https://doc.deno.land/badge.svg)](https://doc.deno.land/https/deno.land/x/unknownutil/mod.ts)
+[![Test](https://github.com/lambdalisue/unknownutil-deno/workflows/Test/badge.svg)](https://github.com/lambdalisue/unknownutil-deno/actions?query=workflow%3ATest)
+
+A utility pack for handling `unknown` type.
+
+[deno]: https://deno.land/
+
+## Usage
+
+### isXXXXX
+
+The `unknownutil` provides the following predicate functions
+
+- `isString(x: unknown): x is string`
+- `isNumber(x: unknown): x is number`
+- `isArray<T extends unknown>(x: unknown, pred?: Predicate<T>): x is T[]`
+- `isObject<T extends unknown>(x: unknown, pred?: Predicate<T>): x is Record<string, T>`
+- `isFunction(x: unknown): x is (...args: unknown[]) => unknown`
+- `isNull(x: unknown): x is null`
+- `isUndefined(x: unknown): x is undefined`
+- `isNone(x: unknown): x is null | undefined`
+
+For example:
+
+```typescript
+import { isString } from "https://deno.land/x/unknownutil/mod.ts";
+
+const a: unknown = "Hello";
+
+if (isString(a)) {
+  // 'a' is 'string' in this block
+}
+```
+
+Additionally, `isArray` and `isObject` supports an inner predicate function to
+predicate `x` more precisely like:
+
+```typescript
+import { isArray, isString } from "https://deno.land/x/unknownutil/mod.ts";
+
+const a: unknown = ["a", "b", "c"];
+
+if (isArray(a)) {
+  // 'a' is 'unknown[]' in this block
+}
+
+if (isArray(a, isString)) {
+  // 'a' is 'string[]' in this block
+}
+```
+
+### ensureXXXXX
+
+The `unknownutil` provides the following ensure functions which will raise
+`EnsureError` when a given `x` is not expected type.
+
+- `ensureString(x: unknown): assert x is string`
+- `ensureNumber(x: unknown): assert x is string`
+- `ensureArray<T extends unknown>(x: unknown, pred?: Predicate<T>): assert x is T[]`
+- `ensureObject<T extends unknown>(x: unknown, pred?: Predicate<T>): x ensure Record<string, T>`
+- `ensureFunction(x: unknown): x ensure (...args: unknown[]) => unknown`
+- `ensureNull(x: unknown): x ensure null`
+- `ensureUndefined(x: unknown): x ensure undefined`
+- `ensureNone(x: unknown): x ensure null | undefined`
+
+For example:
+
+```typescript
+import { ensureString } from "https://deno.land/x/unknownutil/mod.ts";
+
+const a: unknown = "Hello";
+ensureString(a); // Now 'a' is 'string'
+
+const b: unknown = 0;
+ensureString(b); // Raise EnsureError on above while 'b' is not string
+```
+
+Additionally, `ensureArray` and `ensureObject` supports an inner predicate
+function to predicate `x` more precisely like:
+
+```typescript
+import { ensureArray, isString } from "https://deno.land/x/unknownutil/mod.ts";
+
+const a: unknown = ["a", "b", "c"];
+ensureArray(a); // Now 'a' is 'unknown[]'
+ensureArray(a, isString); // Now 'a' is 'string[]'
+
+const b: unknown = [0, 1, 2];
+ensureArray(b); // Now 'b' is 'unknown[]'
+ensureArray(b, isString); // Raise EnsureError on above while 'b' is not string array
+```
+
+## License
+
+The code follows MIT license written in [LICENSE](./LICENSE). Contributors need
+to agree that any modifications sent in this repository follow the license.

deps_test.ts

@@ -0,0 +1 @@
+export * from "https://deno.land/[email protected]/testing/asserts.ts";

ensure.ts

@@ -0,0 +1,102 @@
+import {
+  isArray,
+  isFunction,
+  isNone,
+  isNull,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+  Predicate,
+} from "./is.ts";
+
+export class EnsureError extends Error {
+  constructor(message?: string) {
+    super(message);
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, EnsureError);
+    }
+
+    this.name = "EnsureError";
+  }
+}
+
+/**
+ * Ensure if `x` is expected type by raising an `EnsureError` when it's not.
+ */
+export function ensure<T>(
+  x: unknown,
+  pred: Predicate<T>,
+  message = "The value is not expected type",
+): asserts x is T {
+  if (!pred(x)) {
+    throw new EnsureError(message);
+  }
+}
+
+/**
+ * Ensure if `x` is string by raising an `EnsureError` when it's not.
+ */
+export function ensureString(x: unknown): asserts x is string {
+  return ensure(x, isString, "The value must be string");
+}
+
+/**
+ * Ensure if `x` is number by raising an `EnsureError` when it's not.
+ */
+export function ensureNumber(x: unknown): asserts x is number {
+  return ensure(x, isNumber, "The value must be number");
+}
+
+/**
+ * Ensure if `x` is array by raising an `EnsureError` when it's not.
+ */
+export function ensureArray<T extends unknown>(
+  x: unknown,
+  ipred?: Predicate<T>,
+): asserts x is T[] {
+  const pred = (x: unknown): x is T[] => isArray(x, ipred);
+  return ensure(x, pred, "The value must be array");
+}
+
+/**
+ * Ensure if `x` is object by raising an `EnsureError` when it's not.
+ */
+export function ensureObject<T>(
+  x: unknown,
+  ipred?: Predicate<T>,
+): asserts x is Record<string, T> {
+  const pred = (x: unknown): x is Record<string, T> => isObject(x, ipred);
+  return ensure(x, pred, "The value must be object");
+}
+
+/**
+ * Ensure if `x` is function by raising an `EnsureError` when it's not.
+ */
+export function ensureFunction(
+  x: unknown,
+): asserts x is (...args: unknown[]) => unknown {
+  return ensure(x, isFunction, "The value must be function");
+}
+
+/**
+ * Ensure if `x` is null by raising an `EnsureError` when it's not.
+ */
+export function ensureNull(x: unknown): asserts x is null {
+  return ensure(x, isNull, "The value must be null");
+}
+
+/**
+ * Ensure if `x` is undefined by raising an `EnsureError` when it's not.
+ */
+export function ensureUndefined(x: unknown): asserts x is undefined {
+  return ensure(x, isUndefined, "The value must be undefined");
+}
+
+/**
+ * Ensure if `x` is null or undefined by raising an `EnsureError` when it's not.
+ */
+export function ensureNone(x: unknown): asserts x is null | undefined {
+  return ensure(x, isNone, "The value must be null or undefined");
+}