@react-md/core 1.0.0-next.15 → 1.0.0-next.16

package/src/utils/__tests__/bem.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { bem } from "../bem.js";
-
-describe("bem", () => {
-  const block1 = bem("base");
-  const block2 = bem("button");
-  const block3 = bem("container");
-
-  it("should throw an error if the user provides an empty string", () => {
-    expect(() => bem("")).toThrow(
-      "bem requires a base block class but none were provided."
-    );
-  });
-
-  describe("block", () => {
-    it("should return the base class unmodified if called with no arguments", () => {
-      expect(block1()).toBe("base");
-      expect(block2()).toBe("button");
-      expect(block3()).toBe("container");
-    });
-
-    it("should style the first argument as a element if it is a string", () => {
-      expect(block1("thing")).toBe("base__thing");
-      expect(block2("thing")).toBe("button__thing");
-      expect(block3("thing")).toBe("container__thing");
-    });
-
-    it("should style the first argument as a modifier if it is an object", () => {
-      expect(block2({})).toBe("button");
-      expect(block2({ primary: false })).toBe("button");
-      expect(block2({ primary: true })).toBe("button button--primary");
-      expect(block2({ primary: true, secondary: null })).toBe(
-        "button button--primary"
-      );
-      expect(block2({ primary: true, secondary: 1 })).toBe(
-        "button button--primary button--secondary"
-      );
-    });
-
-    it("should join the element and modifiers together", () => {
-      expect(block2("content", {})).toBe("button__content");
-      expect(block2("content", { primary: false })).toBe("button__content");
-      expect(block2("content", { primary: true })).toBe(
-        "button__content button__content--primary"
-      );
-    });
-
-    it("should throw an error if both arguments are considered a modifier", () => {
-      expect(() => block1({}, {})).toThrow(
-        "bem does not support having two modifier arguments."
-      );
-    });
-  });
-});

package/src/utils/__tests__/getMiddleOfRange.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { getMiddleOfRange } from "../getMiddleOfRange.js";
-
-describe("getMiddleOfRange", () => {
-  it("should return the middle of the range", async () => {
-    expect(getMiddleOfRange({ min: 0, max: 100, step: 1 })).toBe(50);
-    expect(getMiddleOfRange({ min: 0, max: 100, step: 2 })).toBe(50);
-    expect(getMiddleOfRange({ min: 0, max: 100, step: 5 })).toBe(50);
-
-    expect(getMiddleOfRange({ min: 30, max: 80, step: 1 })).toBe(55);
-  });
-});

package/src/utils/__tests__/getPercentage.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import type { GetPercentageOptions } from "../getPercentage.js";
-import { getPercentage } from "../getPercentage.js";
-
-describe("getPercentage", () => {
-  it("should throw a RangeError if the min is greater than the max", () => {
-    const expected = new RangeError(
-      "A range must have the min value less than the max value"
-    );
-    const options1: GetPercentageOptions = {
-      min: 0,
-      max: -100,
-      value: 0,
-      validate: true,
-    };
-    const options2: GetPercentageOptions = {
-      min: 0,
-      max: 0,
-      value: 0,
-      validate: true,
-    };
-    const options3: GetPercentageOptions = {
-      min: 0,
-      max: -100,
-      value: 20,
-      validate: true,
-    };
-    const options4: GetPercentageOptions = {
-      min: 0,
-      max: 0,
-      value: 20,
-      validate: true,
-    };
-    expect(() => getPercentage(options1)).toThrow(expected);
-    expect(() => getPercentage(options2)).toThrow(expected);
-    expect(() => getPercentage(options3)).toThrow(expected);
-    expect(() => getPercentage(options4)).toThrow(expected);
-    expect(() => getPercentage({ ...options1, validate: false })).not.toThrow(
-      expected
-    );
-    expect(() => getPercentage({ ...options2, validate: false })).not.toThrow(
-      expected
-    );
-    expect(() => getPercentage({ ...options3, validate: false })).not.toThrow(
-      expected
-    );
-    expect(() => getPercentage({ ...options4, validate: false })).not.toThrow(
-      expected
-    );
-  });
-
-  it("should throw a RangeError if the value is not between the min anx max", () => {
-    const expected = new RangeError(
-      "A value must be between the min and max values"
-    );
-    const options1: GetPercentageOptions = {
-      min: 0,
-      max: 100,
-      value: -1,
-      validate: true,
-    };
-    const options2: GetPercentageOptions = {
-      min: 0,
-      max: 1,
-      value: -1,
-      validate: true,
-    };
-    const options3: GetPercentageOptions = {
-      min: 0,
-      max: 1,
-      value: -0.5,
-      validate: true,
-    };
-
-    expect(() => getPercentage(options1)).toThrow(expected);
-    expect(() => getPercentage(options2)).toThrow(expected);
-    expect(() => getPercentage(options3)).toThrow(expected);
-    expect(() => getPercentage({ ...options1, validate: false })).not.toThrow(
-      expected
-    );
-    expect(() => getPercentage({ ...options2, validate: false })).not.toThrow(
-      expected
-    );
-    expect(() => getPercentage({ ...options3, validate: false })).not.toThrow(
-      expected
-    );
-  });
-
-  it("should return the value as a decimal between 0 and 1 representing the current percentage", () => {
-    expect(getPercentage({ min: 0, max: 100, value: 20 })).toBe(0.2);
-    expect(getPercentage({ min: 0, max: 10, value: 3 })).toBe(0.3);
-    expect(getPercentage({ min: 0, max: 1, value: 0.5 })).toBe(0.5);
-  });
-
-  it("should always return a positive percentage", () => {
-    expect(getPercentage({ min: -100, max: 0, value: -20 })).toBe(0.8);
-    expect(getPercentage({ min: -10, max: 0, value: -3 })).toBe(0.7);
-    expect(getPercentage({ min: -1, max: 0, value: -0.5 })).toBe(0.5);
-
-    expect(getPercentage({ min: -100, max: 100, value: 0 })).toBe(0.5);
-    expect(getPercentage({ min: -100, max: 0, value: 0 })).toBe(1);
-    expect(getPercentage({ min: -100, max: 0, value: -25 })).toBe(0.75);
-  });
-});

package/src/utils/__tests__/getRangeDefaultValue.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { getRangeDefaultValue } from "../getRangeDefaultValue.js";
-
-describe("getRangeDefaultValue", () => {
-  it("should return the default value if it is defined", async () => {
-    expect(
-      getRangeDefaultValue({ min: 0, max: 100, step: 1, defaultValue: 10 })
-    ).toBe(10);
-    expect(
-      getRangeDefaultValue({ min: 0, max: 100, step: 1, defaultValue: 50 })
-    ).toBe(50);
-
-    const defaultValueSetter = (): number => 30;
-    expect(
-      getRangeDefaultValue({
-        min: 10,
-        max: 30,
-        step: 1,
-        defaultValue: defaultValueSetter,
-      })
-    ).toBe(defaultValueSetter);
-  });
-
-  it("should return a function that returns the middle of the range when the defaultValue is undefined", () => {
-    const initializer1 = getRangeDefaultValue({
-      min: 0,
-      max: 100,
-      step: 1,
-    });
-    const initializer2 = getRangeDefaultValue({
-      min: 0,
-      max: 100,
-      step: 1,
-      defaultValue: undefined,
-    });
-
-    if (typeof initializer1 !== "function") {
-      throw new Error("initializer1 is not a function");
-    }
-    if (typeof initializer2 !== "function") {
-      throw new Error("initializer2 is not a function");
-    }
-
-    expect(initializer1()).toBe(50);
-    expect(initializer2()).toBe(50);
-  });
-});

package/src/utils/__tests__/getRangeSteps.ts

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { getRangeSteps } from "../getRangeSteps.js";
-
-describe("getRangeSteps", () => {
-  it("should work as expected", () => {
-    expect(getRangeSteps({ min: 0, max: 100, step: 1 })).toBe(100);
-    expect(getRangeSteps({ min: 0, max: 100, step: 10 })).toBe(10);
-    expect(getRangeSteps({ min: 0, max: 10, step: 1 })).toBe(10);
-    expect(getRangeSteps({ min: 0, max: 100, step: 10 })).toBe(10);
-    expect(getRangeSteps({ min: -10, max: 10, step: 1 })).toBe(20);
-    expect(getRangeSteps({ min: -10, max: 10, step: 0.5 })).toBe(40);
-    expect(getRangeSteps({ min: 0.1, max: 0.9, step: 0.05 })).toBe(16);
-  });
-});

package/src/utils/__tests__/loop.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { loop } from "../loop.js";
-
-describe("loop", () => {
-  it("should increase the number by 1 when the number is less than or equal to the max number", () => {
-    expect(loop({ value: 0, max: 3, increment: true })).toBe(1);
-    expect(loop({ value: 0, max: 1, increment: true })).toBe(1);
-    expect(loop({ value: 1, max: 100, increment: true })).toBe(2);
-  });
-
-  it("should decrease the number by 1 when the number is greater than 0", () => {
-    expect(loop({ value: 1, max: 3, increment: false })).toBe(0);
-    expect(loop({ value: 1, max: 1, increment: false })).toBe(0);
-    expect(loop({ value: 100, max: 100, increment: false })).toBe(99);
-  });
-
-  it("should correctly loop around to 0 when the number is the max value and incrementing", () => {
-    expect(loop({ value: 100, max: 100, increment: true })).toBe(0);
-    expect(loop({ value: 1, max: 1, increment: true })).toBe(0);
-    expect(loop({ value: 20, max: 20, increment: true })).toBe(0);
-  });
-
-  it("should correctly loop around to the max value when the number is 0 and decrementing", () => {
-    expect(loop({ value: 0, max: 100, increment: false })).toBe(100);
-    expect(loop({ value: 0, max: 1, increment: false })).toBe(1);
-    expect(loop({ value: 0, max: 20, increment: false })).toBe(20);
-  });
-
-  it("should only keep the number between 0 and the max value if the minmax arg is enabled", () => {
-    expect(loop({ value: -1, max: 20, increment: true, minmax: true })).toBe(0);
-    expect(loop({ value: -1, max: 20, increment: false, minmax: true })).toBe(
-      0
-    );
-    expect(loop({ value: 100, max: 20, increment: true, minmax: true })).toBe(
-      20
-    );
-    expect(loop({ value: 100, max: 20, increment: false, minmax: true })).toBe(
-      20
-    );
-  });
-
-  it("should allow for a custom min value", () => {
-    expect(loop({ value: 0, min: 1, max: 10, increment: false })).toBe(10);
-    expect(loop({ value: 0, min: -10, max: 10, increment: false })).toBe(-1);
-    expect(loop({ value: -10, min: -10, max: 10, increment: false })).toBe(10);
-
-    // defaults to 0
-    expect(loop({ value: 0, max: 10, increment: false })).toBe(10);
-  });
-});

package/src/utils/__tests__/nearest.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { nearest } from "../nearest.js";
-
-describe("nearest", () => {
-  it("should round correctly", () => {
-    expect(nearest({ value: 1, min: 0, max: 1, steps: 1 })).toBe(1);
-    expect(nearest({ value: 0, min: 0, max: 100, steps: 100 })).toBe(0);
-
-    expect(nearest({ value: 28, min: 0, max: 100, steps: 10 })).toBe(30);
-    expect(nearest({ value: 28.7, min: 0, max: 100, steps: 10 })).toBe(30);
-    expect(nearest({ value: 28.3, min: 0, max: 100, steps: 100 })).toBe(28);
-    expect(nearest({ value: 28.7, min: 0, max: 100, steps: 100 })).toBe(29);
-
-    expect(nearest({ value: 2.75, min: 0, max: 10, steps: 10 })).toBe(3);
-    expect(nearest({ value: 5.12, min: 5, max: 6, steps: 10 })).toBe(5.1);
-    expect(nearest({ value: 0.06, min: 0, max: 1, steps: 10 })).toBe(0.1);
-
-    expect(nearest({ value: 0.12, min: 0, max: 1, steps: 4 })).toBe(0);
-    expect(nearest({ value: 0.13, min: 0, max: 1, steps: 4 })).toBe(0.25);
-    expect(nearest({ value: 0.24, min: 0, max: 1, steps: 4 })).toBe(0.25);
-    expect(nearest({ value: 0.28, min: 0, max: 1, steps: 4 })).toBe(0.25);
-    expect(nearest({ value: 0.33, min: 0, max: 1, steps: 4 })).toBe(0.25);
-  });
-
-  it("should allow for a custom range to be used with range sliders", () => {
-    // to explain this a bit better, need to make sure that the slider thumbs
-    // are always in order of `min -> max` so the min and max values change
-    // depending on which thumb is being dragged:
-    // - thumb1 -> min === min, max === thumb2Value
-    // - thumb2 -> min === thumb1Value, max === max
-
-    expect(
-      nearest({ value: 44.3, min: 40, max: 100, steps: 100, range: 100 })
-    ).toBe(44);
-    expect(nearest({ value: 50, min: 20, max: 50, steps: 50, range: 50 })).toBe(
-      50
-    );
-    expect(
-      nearest({ value: 22.3, min: 20, max: 50, steps: 50, range: 50 })
-    ).toBe(22);
-    expect(
-      nearest({ value: 12.3, min: 20, max: 50, steps: 50, range: 50 })
-    ).toBe(20);
-    expect(
-      nearest({ value: 0, min: 30, max: 50, steps: 100, range: 100 })
-    ).toBe(30);
-
-    // it's possible for the value to be larger than the min or max for range
-    // sliders now that it supports a "current drag value" vs _real_ value
-    const min = 100;
-    const max = 10000;
-    const range = max - min;
-    const steps = range;
-    const minValue = 2000;
-    const maxValue = 8000;
-    expect(nearest({ value: 10000, min, max: maxValue, steps, range })).toBe(
-      maxValue
-    );
-    expect(nearest({ value: 0, min: minValue, max, steps, range })).toBe(
-      minValue
-    );
-  });
-
-  it("should just return the min/max value if they are equal to support range sliders that have values one step apart", () => {
-    expect(
-      nearest({
-        min: 100,
-        max: 100,
-        steps: 0,
-        value: 100,
-      })
-    ).toBe(100);
-
-    expect(
-      nearest({
-        min: 100,
-        max: 100,
-        steps: 0,
-        value: 103,
-      })
-    ).toBe(100);
-  });
-});

package/src/utils/__tests__/parseCssLengthUnit.node.ts

@@ -1,28 +0,0 @@
-/** @jest-environment node */
-import { describe, expect, it } from "@jest/globals";
-import { parseCssLengthUnit } from "../parseCssLengthUnit.js";
-
-describe("parseCssLengthUnit", () => {
-  it("should return the correct value for numbers and px strings", () => {
-    expect(typeof document).toBe("undefined");
-    expect(parseCssLengthUnit({ value: 0 })).toBe(0);
-    expect(parseCssLengthUnit({ value: 1 })).toBe(1);
-    expect(parseCssLengthUnit({ value: -16 })).toBe(-16);
-
-    expect(parseCssLengthUnit({ value: "0" })).toBe(0);
-    expect(parseCssLengthUnit({ value: "-4px" })).toBe(-4);
-    expect(parseCssLengthUnit({ value: "16px" })).toBe(16);
-  });
-
-  it("should multiply fontSizeFallback or 16 to the value if the document is undefined for non-px strings", () => {
-    expect(typeof document).toBe("undefined");
-    expect(parseCssLengthUnit({ value: "1.em" })).toBe(16);
-    expect(parseCssLengthUnit({ value: ".5em" })).toBe(8);
-    expect(parseCssLengthUnit({ value: "1rem", fallbackFontSize: 12 })).toBe(
-      12
-    );
-    expect(parseCssLengthUnit({ value: ".5rem", fallbackFontSize: 12 })).toBe(
-      6
-    );
-  });
-});

package/src/utils/__tests__/parseCssLengthUnit.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it, jest } from "@jest/globals";
-import { parseCssLengthUnit } from "../parseCssLengthUnit.js";
-
-describe("parseCssLengthUnit", () => {
-  it("should return the correct value for numbers and px strings", () => {
-    expect(parseCssLengthUnit({ value: 0 })).toBe(0);
-    expect(parseCssLengthUnit({ value: 1 })).toBe(1);
-    expect(parseCssLengthUnit({ value: -16 })).toBe(-16);
-
-    expect(parseCssLengthUnit({ value: "0" })).toBe(0);
-    expect(parseCssLengthUnit({ value: "-4px" })).toBe(-4);
-    expect(parseCssLengthUnit({ value: "16px" })).toBe(16);
-  });
-
-  it("should parse the fontSize style for em/rem units", () => {
-    const defaultStyle = window.getComputedStyle(document.documentElement);
-    const getComputedStyle = jest
-      .spyOn(window, "getComputedStyle")
-      .mockImplementation((element) => {
-        if (element === document.documentElement) {
-          return {
-            ...defaultStyle,
-            fontSize: "13px",
-          };
-        }
-
-        return {
-          ...defaultStyle,
-          fontSize: "14px",
-        };
-      });
-
-    const container = document.createElement("div");
-
-    expect(parseCssLengthUnit({ value: "1.5em" })).toBe(19.5);
-    expect(parseCssLengthUnit({ value: ".5em" })).toBe(6.5);
-    expect(parseCssLengthUnit({ value: "1.5rem" })).toBe(19.5);
-    expect(parseCssLengthUnit({ value: ".5rem" })).toBe(6.5);
-
-    expect(parseCssLengthUnit({ value: "1.5em", container })).toBe(21);
-    expect(parseCssLengthUnit({ value: ".5em", container })).toBe(7);
-    expect(parseCssLengthUnit({ value: "1.5rem", container })).toBe(19.5);
-    expect(parseCssLengthUnit({ value: ".5rem", container })).toBe(6.5);
-
-    getComputedStyle.mockRestore();
-  });
-});

package/src/utils/__tests__/wait.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { wait } from "../wait.js";
-
-describe("wait", () => {
-  it("should wait the duration and the resolve", async () => {
-    const startTime = Date.now();
-    await wait(1000);
-    const endTime = Date.now();
-
-    expect(endTime - startTime).toBeGreaterThanOrEqual(1000);
-  });
-});

package/src/utils/__tests__/withinRange.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { withinRange } from "../withinRange.js";
-
-describe("withinRange", () => {
-  it("should return the value if the min or max values are undefined", () => {
-    expect(withinRange({ value: 100, min: undefined, max: undefined })).toBe(
-      100
-    );
-    expect(withinRange({ value: 0, min: undefined, max: undefined })).toBe(0);
-    expect(withinRange({ value: -100, min: undefined, max: undefined })).toBe(
-      -100
-    );
-  });
-
-  it("should return the correct value based on the min and max values", () => {
-    expect(withinRange({ value: 0, min: 0, max: 10 })).toBe(0);
-    expect(withinRange({ value: -1, min: 0, max: 10 })).toBe(0);
-    expect(withinRange({ value: -0.00000001, min: 0, max: 10 })).toBe(0);
-    expect(withinRange({ value: 20, min: 0, max: 20 })).toBe(20);
-    expect(withinRange({ value: 20, min: 0, max: 19 })).toBe(19);
-    expect(withinRange({ value: 10.5, min: 10, max: 11 })).toBe(10.5);
-    expect(withinRange({ value: 10.5, min: 9, max: 10 })).toBe(10);
-  });
-});

package/src/window-splitter/_window-splitter.scss

@@ -1,143 +0,0 @@
-@use "sass:map";
-@use "../utils";
-@use "../interaction/interaction";
-@use "../transition/transition";
-
-$disable-everything: false !default;
-$disable-horizontal: false !default;
-$disable-vertical: false !default;
-$disable-reversed: false !default;
-$disable-absolute-position: false !default;
-
-$size: 1rem !default;
-$background-size: 0.25rem !default;
-$background-color: interaction.get-var(focus-color) !default;
-$z-index: 30 !default;
-
-$variables: (top, right, bottom, left, opacity, position);
-
-@function get-var($name, $fallback: null) {
-  $var: utils.get-var-name($variables, $name, "window-splitter");
-  // window-splitter variables don't make much sense to set globally
-  $value: if($fallback, $fallback, 0);
-  @if $value {
-    @return var(#{$var}, #{$value});
-  }
-
-  @return var(#{$var});
-}
-
-@mixin set-var($name, $value) {
-  @if $value {
-    #{utils.get-var-name($variables, $name, "window-splitter")}: #{$value};
-  }
-}
-
-@mixin use-var($property, $name: $property, $fallback: null) {
-  #{$property}: get-var($name, $fallback);
-}
-
-@mixin styles($disable-layer: false) {
-  @if not $disable-everything {
-    @include utils.optional-layer(window-splitter, $disable-layer) {
-      .rmd-window-splitter {
-        @include use-var(opacity);
-        @include utils.mouse-hover {
-          @include set-var(opacity, 1);
-        }
-        @include utils.keyboard-only {
-          // Do not use `:focus-visible` here since since it'll still be active
-          // after dragging with a mouse until the user clicks something else. The
-          // `--dragging` state handles that part
-          &:focus {
-            @include set-var(opacity, 1);
-          }
-        }
-
-        background-color: transparent;
-        border: 0;
-        outline-style: none;
-        padding: 0;
-        position: fixed;
-        transition: opacity transition.$linear-duration;
-        z-index: $z-index;
-
-        &::after {
-          background-color: $background-color;
-          content: "";
-          inset: 0;
-          position: absolute;
-        }
-
-        @if not $disable-horizontal {
-          &--h {
-            @include utils.auto-rtl(left, get-var(position));
-            @include use-var(bottom);
-            @include use-var(top);
-
-            cursor: col-resize;
-            width: $size;
-
-            &::after {
-              width: $background-size;
-            }
-          }
-
-          @if not $disable-reversed {
-            &--hr {
-              @include utils.auto-rtl(right, get-var(position));
-
-              left: auto;
-
-              &::after {
-                @include utils.auto-rtl(margin-left, auto);
-              }
-            }
-          }
-        }
-
-        @if not $disable-vertical {
-          &--v {
-            @include use-var(left);
-            @include use-var(right);
-            @include use-var(top, position);
-
-            cursor: row-resize;
-            height: $size;
-            width: 100%;
-
-            &::after {
-              height: $background-size;
-            }
-          }
-
-          @if not $disable-reversed {
-            &--vr {
-              @include use-var(bottom, position);
-
-              top: auto;
-
-              &::after {
-                top: calc(100% - $background-size);
-              }
-            }
-          }
-        }
-
-        @if not $disable-absolute-position {
-          &--a {
-            position: absolute;
-          }
-        }
-
-        &--dragging {
-          @include set-var(opacity, 1);
-
-          // set to important so that the `.rmd-dragging` styles do not affect
-          // window splitter
-          pointer-events: auto !important;
-        }
-      }
-    }
-  }
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "nodenext",
-    "strict": true,
-    "noEmit": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "moduleResolution": "nodenext",
-    "resolveJsonModule": true,
-    "downlevelIteration": true,
-    "noFallthroughCasesInSwitch": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "jsx": "preserve",
-    "lib": ["dom", "dom.iterable", "esnext"]
-  },
-  "exclude": ["node_modules", "dist"]
-}

package/tsconfig.types.json

@@ -1,12 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig.json",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false,
-    "declaration": true,
-    "declarationDir": "./dist",
-    "emitDeclarationOnly": true
-  },
-  "include": ["src/**/*.ts", "src/**/*.tsx"],
-  "exclude": ["node_modules", "**/__tests__/**"]
-}

package/tsdoc.json

@@ -1,14 +0,0 @@
-{
-  "$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
-  "extends": ["@microsoft/api-extractor/extends/tsdoc-base.json"],
-  "supportForTags": {
-    "@since": true
-  },
-  "tagDefinitions": [
-    {
-      "tagName": "@since",
-      "syntaxKind": "block",
-      "allowMultiple": true
-    }
-  ]
-}