inferred-types 0.34.2 → 0.35.0

package/dist/index.d.ts

@@ -1257,6 +1257,34 @@ type SpaceToDash<T extends string> = T extends `${infer Begin}${" "}${infer Rest
  * ``` */
 type SnakeCase<S extends string> = string extends S ? string : DashUppercase<Uncapitalize<SpaceToDash<Trim<LowerAllCaps<S>>>>> extends `${infer Begin}${"-"}${infer Rest}` ? SnakeCase<`${Lowercase<Begin>}_${Rest}`> : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;
 
+/**
+ * **StripStarting**`<T, U>`
+ *
+ * Will strip off of `T` the starting string defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = "Hello ";
+ * // "World"
+ * type R = StripStarting<T,U>;
+ * ```
+ */
+type StripStarting<T extends string, U extends string> = IfLiteral<T, string extends U ? never : T extends `${U}${infer After}` ? After : T, string>;
+
+/**
+ * **StripEnding**`<T, U>`
+ *
+ * Will strip off of `T` the ending defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = " World";
+ * // "Hello"
+ * type R = StripEnding<T,U>;
+ * ```
+ */
+type StripEnding<T extends string, U extends string> = IfLiteral<T, string extends U ? never : T extends `${infer Before}${U}` ? Before : T, string>;
+
 type NetworkProtocol = "http" | "https" | "file" | "ws" | "wss";
 /**
  * A literal variant of _string_ which is meant to represent a domain name
@@ -2235,6 +2263,10 @@ declare function idTypeGuard<T extends {
  */
 declare function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T): T;
 
+declare function stripEnding<T extends string, U extends string>(content: T, strip: U): StripEnding<T, U>;
+
+declare function stripStarting<T extends string, U extends string>(content: T, strip: U): StripStarting<T, U>;
+
 /**
  * **Suggest**
  *
@@ -2541,4 +2573,4 @@ interface IFluentConfigurator<C> {
  */
 declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;
 
-export { AfterFirst, AllCaps, Alpha, AlphaNumeric, AnyFunction, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Box, BoxValue, BoxedFnParams, BoxedReturn, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, Contains, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DomainName, DynamicRule, DynamicRuleSet, Email, EndsWith, EnumValues, Equal, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FilterTuple, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FirstOrUndefined, FirstString, FluentConfigurator, FluentFunction, FnShape, FromDictArray, FullyQualifiedUrl, FunctionType, GeneralDictionary, Get, HasUppercase, HybridFunction, IConfigurator, IFluentConfigurator, If, IfArray, IfBooleanLiteral, IfEndsWith, IfExtends, IfExtendsThen, IfFalse, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfReadonlyArray, IfScalar, IfStartsWith, IfStringLiteral, IfTrue, IfUndefined, Include, Includes, IntersectingKeys, Ipv4, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNull, IsNumber, IsNumericLiteral, IsObject, IsOptionalLiteral, IsReadonlyArray, IsScalar, IsStringLiteral, IsTrue, IsUndefined, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityFrom, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapInputFrom, MapOR, MapOutput, MapOutputFrom, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Mutable, MutableProps, NarrowBox, Narrowable, NarrowlyContains, NetworkProtocol, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotEqual, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Or, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, RelativeUrl, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimpleFunction, SimplifyObject, SnakeCase, SpecialCharacters, Split, StartsWith, StringDelimiter, StringFilter, StringKeys, StringLength, Suggest, SuggestNumeric, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, Unbox, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, UrlBuilder, VariableName, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, box, condition, createFnWithProps, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifArray, ifArrayPartial, ifBoolean, ifFalse, ifNull, ifNumber, ifString, ifTrue, ifUndefined, isArray, isBoolean, isBox, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, unbox, withValue };
+export { AfterFirst, AllCaps, Alpha, AlphaNumeric, AnyFunction, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Box, BoxValue, BoxedFnParams, BoxedReturn, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, Contains, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DomainName, DynamicRule, DynamicRuleSet, Email, EndsWith, EnumValues, Equal, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FilterTuple, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FirstOrUndefined, FirstString, FluentConfigurator, FluentFunction, FnShape, FromDictArray, FullyQualifiedUrl, FunctionType, GeneralDictionary, Get, HasUppercase, HybridFunction, IConfigurator, IFluentConfigurator, If, IfArray, IfBooleanLiteral, IfEndsWith, IfExtends, IfExtendsThen, IfFalse, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfReadonlyArray, IfScalar, IfStartsWith, IfStringLiteral, IfTrue, IfUndefined, Include, Includes, IntersectingKeys, Ipv4, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNull, IsNumber, IsNumericLiteral, IsObject, IsOptionalLiteral, IsReadonlyArray, IsScalar, IsStringLiteral, IsTrue, IsUndefined, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityFrom, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapInputFrom, MapOR, MapOutput, MapOutputFrom, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Mutable, MutableProps, NarrowBox, Narrowable, NarrowlyContains, NetworkProtocol, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotEqual, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Or, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, RelativeUrl, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimpleFunction, SimplifyObject, SnakeCase, SpecialCharacters, Split, StartsWith, StringDelimiter, StringFilter, StringKeys, StringLength, StripEnding, StripStarting, Suggest, SuggestNumeric, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, Unbox, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, UrlBuilder, VariableName, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, box, condition, createFnWithProps, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifArray, ifArrayPartial, ifBoolean, ifFalse, ifNull, ifNumber, ifString, ifTrue, ifUndefined, isArray, isBoolean, isBox, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, readonlyFnWithProps, ruleSet, strArrayToDict, stripEnding, stripStarting, type, typeApi, unbox, withValue };

package/dist/index.js

@@ -87,6 +87,8 @@ __export(src_exports, {
   readonlyFnWithProps: () => readonlyFnWithProps,
   ruleSet: () => ruleSet,
   strArrayToDict: () => strArrayToDict,
+  stripEnding: () => stripEnding,
+  stripStarting: () => stripStarting,
   type: () => type,
   typeApi: () => typeApi,
   unbox: () => unbox,
@@ -776,6 +778,18 @@ function idTypeGuard(_o) {
 function literal(obj) {
   return obj;
 }
+
+// src/runtime/literals/stripEnding.ts
+function stripEnding(content, strip) {
+  const re = new RegExp(`(.*)${strip}$`);
+  return content.endsWith(strip) ? content.replace(re, "$1") : content;
+}
+
+// src/runtime/literals/stripStarting.ts
+function stripStarting(content, strip) {
+  const re = new RegExp(`^${strip}(.*)`);
+  return content.startsWith(strip) ? content.replace(re, "$1") : content;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Configurator,
@@ -845,6 +859,8 @@ function literal(obj) {
   readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
+  stripEnding,
+  stripStarting,
   type,
   typeApi,
   unbox,

package/dist/index.mjs

@@ -680,6 +680,18 @@ function idTypeGuard(_o) {
 function literal(obj) {
   return obj;
 }
+
+// src/runtime/literals/stripEnding.ts
+function stripEnding(content, strip) {
+  const re = new RegExp(`(.*)${strip}$`);
+  return content.endsWith(strip) ? content.replace(re, "$1") : content;
+}
+
+// src/runtime/literals/stripStarting.ts
+function stripStarting(content, strip) {
+  const re = new RegExp(`^${strip}(.*)`);
+  return content.startsWith(strip) ? content.replace(re, "$1") : content;
+}
 export {
   Configurator,
   DEFAULT_MANY_TO_ONE_MAPPING,
@@ -748,6 +760,8 @@ export {
   readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
+  stripEnding,
+  stripStarting,
   type,
   typeApi,
   unbox,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.34.2",
+  "version": "0.35.0",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",
@@ -32,16 +32,16 @@
   },
   "devDependencies": {
     "@type-challenges/utils": "~0.1.1",
-    "@types/node": "^16.18.3",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "@vitest/ui": "^0.25.3",
+    "@types/node": "^16.18.4",
+    "@typescript-eslint/eslint-plugin": "^5.45.1",
+    "@typescript-eslint/parser": "^5.45.1",
+    "@vitest/ui": "^0.25.4",
     "bumpp": "^8.2.1",
     "common-types": "^1.33.2",
     "cross-env": "^7.0.3",
     "dd": "^0.25.4",
     "dotenv": "^16.0.3",
-    "eslint": "^8.28.0",
+    "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-prettier": "^4.2.1",
@@ -53,8 +53,8 @@
     "sharp": "^0.31.2",
     "tsup": "^6.5.0",
     "typescript": "^4.9.3",
-    "vite": "^3.2.4",
-    "vitest": "^0.25.3"
+    "vite": "^3.2.5",
+    "vitest": "^0.25.4"
   },
   "dependencies": {
     "brilliant-errors": "^0.6.1"

package/src/runtime/literals/index.ts

@@ -10,6 +10,8 @@ export * from "./box";
 export * from "./defineType";
 export * from "./identity";
 export * from "./literal";
+export * from "./stripEnding";
+export * from "./stripStarting";
 export * from "./Suggest";
 
 // #endregion auto-indexed files

package/src/runtime/literals/pathJoin.ts

@@ -0,0 +1,17 @@
+import { PathJoin } from "src/types/alphabetic/PathJoin";
+import { stripStarting } from "./stripStarting";
+import { stripEnding } from "./stripEnding";
+
+/**
+ * **pathJoin**`<T,U>()`
+ *
+ * Run time utility which joins two strings together with
+ * the intent to have them be divided by a Posix `/` character
+ * appropriate for Unix file paths and URLs.
+ */
+export function pathJoin<T extends string, U extends string>(begin: T, finish: U): PathJoin<T, U> {
+  const start = stripEnding(begin, "/");
+  const end = stripStarting(finish, "/");
+
+  return `${start}/${end}` as PathJoin<T, U>;
+}

package/src/runtime/literals/stripEnding.ts

@@ -0,0 +1,9 @@
+import { StripEnding } from "src/types/alphabetic/StripEnding";
+
+export function stripEnding<T extends string, U extends string>(
+  content: T,
+  strip: U
+): StripEnding<T, U> {
+  const re = new RegExp(`(.*)${strip}$`);
+  return (content.endsWith(strip) ? content.replace(re, "$1") : content) as StripEnding<T, U>;
+}

package/src/runtime/literals/stripStarting.ts

@@ -0,0 +1,15 @@
+import { StripStarting } from "src/types/alphabetic/StripStarting";
+
+export function stripStarting<T extends string, U extends string>(
+  content: T,
+  strip: U
+): StripStarting<T, U> {
+  const re = new RegExp(`^${strip}(.*)`);
+  return (
+    content.startsWith(strip)
+      ? // starts with
+        content.replace(re, "$1")
+      : // does not
+        content
+  ) as StripStarting<T, U>;
+}

package/src/types/alphabetic/PathJoin.ts

@@ -0,0 +1,40 @@
+import { IfLiteral } from "../boolean-logic";
+import { StripEnding } from "./StripEnding";
+import { StripStarting } from "./StripStarting";
+/**
+ * **PathJoin**`<T,U>`
+ *
+ * Type utility which joins two strings together with the
+ * goal of making it a valid file or URI path (based on the
+ * Posix standard for file paths).
+ *
+ * Primarily, this means that it ensures that both `T` and `U`
+ * are separated by a single `/` character. Of course if either
+ * `T` or `U` are _wide_ string types then the resulting type
+ * will be more limited.
+ *
+ * **Note:** that in the case that both `T` and `U` are wide,
+ * we opt to type the result as just a _string_ rather than
+ * `${string}/${string}` which might be more precise 99% of
+ * the time but where `T` is an empty string there actually
+ * is no guarantee of a `/` character. Similarly we must
+ * type the case where `U` is narrow but `T` is wide as
+ * being `${string}${U}` instead of `${string}/${U}`.
+ */
+export type PathJoin<
+  // leading string
+  T extends string,
+  // trailing string
+  U extends string
+> = IfLiteral<
+  T,
+  // Literal T guaranteed
+  IfLiteral<
+    // conditional
+    U,
+    `${StripEnding<T, "/">}/${StripStarting<U, "/">}`,
+    `${StripEnding<T, "/">}/${string}`
+  >,
+  // wide `T` encountered
+  IfLiteral<U, `${string}${U}`, string>
+>;

package/src/types/alphabetic/StripEnding.ts

@@ -0,0 +1,23 @@
+import { IfLiteral } from "../boolean-logic/IsLiteral";
+
+/**
+ * **StripEnding**`<T, U>`
+ *
+ * Will strip off of `T` the ending defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = " World";
+ * // "Hello"
+ * type R = StripEnding<T,U>;
+ * ```
+ */
+export type StripEnding<T extends string, U extends string> = IfLiteral<
+  // can only operate on literal strings
+  T,
+  // this path represents successful strip opp
+  // but we must never accept `U` being wide
+  string extends U ? never : T extends `${infer Before}${U}` ? Before : T,
+  // here we must stay wide
+  string
+>;

package/src/types/alphabetic/StripStarting.ts

@@ -0,0 +1,23 @@
+import { IfLiteral } from "../boolean-logic/IsLiteral";
+
+/**
+ * **StripStarting**`<T, U>`
+ *
+ * Will strip off of `T` the starting string defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = "Hello ";
+ * // "World"
+ * type R = StripStarting<T,U>;
+ * ```
+ */
+export type StripStarting<T extends string, U extends string> = IfLiteral<
+  // can only operate on literal strings
+  T,
+  // this path represents successful strip opp
+  // but we must never accept `U` being wide
+  string extends U ? never : T extends `${U}${infer After}` ? After : T,
+  // here we must stay wide
+  string
+>;

package/src/types/alphabetic/index.ts

@@ -18,6 +18,8 @@ export * from "./LowerAllCaps";
 export * from "./PascalCase";
 export * from "./Pluralize";
 export * from "./SnakeCase";
+export * from "./StripStarting";
+export * from "./StripEnding";
 export * from "./alpha-characters";
 export * from "./Url";
 

package/tests/literals/PathJoin.test.ts

@@ -0,0 +1,87 @@
+import { Equal, Expect } from "@type-challenges/utils";
+import { pathJoin } from "src/runtime/literals/pathJoin";
+import { PathJoin } from "src/types/alphabetic/PathJoin";
+import { describe, expect, it } from "vitest";
+
+// Note: type tests fail visible inspection but pass from Vitest
+// standpoint so always be sure to run `tsc --noEmit` over your test files to
+// gain validation that no new type vulnerabilities have cropped up.
+
+describe("PathJoin<T,U>", () => {
+  it("only literals / happy path", () => {
+    type T1 = PathJoin<"foo", "bar">;
+    type T2 = PathJoin<"foo/", "bar">;
+    type T3 = PathJoin<"foo", "/bar">;
+    type T4 = PathJoin<"foo/", "/bar">;
+
+    type cases = [
+      // neither have divider
+      Expect<Equal<T1, "foo/bar">>,
+      // one has, one does not
+      Expect<Equal<T2, "foo/bar">>,
+      Expect<Equal<T3, "foo/bar">>,
+      // both have
+      Expect<Equal<T4, "foo/bar">>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+
+  it("wide types mixed in", () => {
+    type T1 = PathJoin<"foo", string>;
+    type T2 = PathJoin<"foo/", string>;
+    type T3 = PathJoin<string, "/bar">;
+    type T4 = PathJoin<string, "bar">;
+
+    type cases = [
+      Expect<Equal<T1, `foo/${string}`>>,
+      Expect<Equal<T2, `foo/${string}`>>,
+      Expect<Equal<T3, `${string}/bar`>>,
+      Expect<Equal<T4, `${string}bar`>>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+});
+
+describe("pathJoin() runtime util", () => {
+  it("happy path", () => {
+    const t1 = pathJoin("foo", "bar" as string);
+    const t2 = pathJoin("foo/", "bar" as string);
+    const t3 = pathJoin("foo" as string, "/bar");
+    const t4 = pathJoin("foo/" as string, "/bar");
+    const t5 = pathJoin("foo/" as string, "bar");
+
+    // runtime tests
+    [t1, t2, t3, t4].forEach((test) => expect(test).toBe("foo/bar"));
+
+    // type tests
+    type cases = [
+      Expect<Equal<typeof t1, `foo/${string}`>>,
+      Expect<Equal<typeof t2, `foo/${string}`>>,
+      Expect<Equal<typeof t3, `${string}/bar`>>,
+      Expect<Equal<typeof t4, `${string}/bar`>>,
+      Expect<Equal<typeof t5, `${string}bar`>>
+    ];
+    const cases: cases = [true, true, true, true, true];
+  });
+
+  it("with wide types", () => {
+    const t1 = pathJoin("foo", "bar");
+    const t2 = pathJoin("foo/", "bar");
+    const t3 = pathJoin("foo", "/bar");
+    const t4 = pathJoin("foo/", "/bar");
+    // runtime tests
+    [t1, t2, t3, t4].forEach((test) => expect(test, "runtime failure").toBe("foo/bar"));
+
+    // type tests
+    type cases = [
+      // neither have divider
+      Expect<Equal<typeof t1, "foo/bar">>,
+      // one has, one does not
+      Expect<Equal<typeof t2, "foo/bar">>,
+      Expect<Equal<typeof t3, "foo/bar">>,
+      // both have
+      Expect<Equal<typeof t4, "foo/bar">>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+});