shelving 1.193.0 → 1.193.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.193.0",
+	"version": "1.193.2",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/store/PathStore.js

@@ -1,4 +1,4 @@
-import { isPathActive, isPathProud, requireAbsolutePath } from "../util/path.js";
+import { isPathActive, isPathProud, requirePath } from "../util/path.js";
 import { BusyStore } from "./BusyStore.js";
 /**
  * Store an absolute path, e.g. `/a/b/c`
@@ -10,12 +10,12 @@ export class PathStore extends BusyStore {
     base;
     // Override to set default path to `.` and base to `/`
     constructor(path = ".", base = "/") {
-        super(requireAbsolutePath(path, base, PathStore));
+        super(requirePath(path, base, PathStore));
         this.base = base;
     }
     // Override to convert a possible path to an absolute path (relative to `this.base`).
     _convert(possible, caller) {
-        return requireAbsolutePath(possible, this.base, caller);
+        return requirePath(possible, this.base, caller);
     }
     // Override for fast equality.
     _equal(a, b) {
@@ -31,7 +31,7 @@ export class PathStore extends BusyStore {
     }
     /** Get an absolute path from a path relative to the current store path. */
     getPath(path) {
-        return requireAbsolutePath(path, this.value);
+        return requirePath(path, this.value);
     }
     toString() {
         return this.value;

package/util/path.d.ts

@@ -3,12 +3,10 @@ import type { AnyCaller } from "./function.js";
 import type { Nullish } from "./null.js";
 /** Absolute path string starts with `/` slash. */
 export type AbsolutePath = `/` | `/${string}`;
-/** Base path string starts with `/` slash and ends with `/` */
-export type BasePath = `/` | `/${string}`;
 /** Relative path string is `.` dot, or starts with `./` dot slash. */
 export type RelativePath = `.` | `./` | `./${string}`;
-/** Simple path string like `a/b/c` */
-export type SimplePath = string;
+/** Either an absolute or relative path. */
+export type Path = AbsolutePath | RelativePath;
 /** Things that can be converted to a path. */
 export type PossiblePath = string;
 /** List of non-empty path segments. */
@@ -44,7 +42,7 @@ export declare function joinPath(...segments: PathSegments): AbsolutePath;
  * @param base Absolute path used for resolving relative paths in `possible`
  * @return Absolute path with a leading slash but no trailing slash, e.g. `/a/c/b`
  */
-export declare function getAbsolutePath(path: Nullish<PossiblePath>, base?: AbsolutePath): AbsolutePath | undefined;
+export declare function getPath(path: Nullish<PossiblePath>, base?: AbsolutePath): AbsolutePath | undefined;
 /**
  * Resolve a relative or absolute path and return the path, or throw `RequiredError` if not a valid path.
  * - Internally uses `new URL` to do path processing but shouldn't ever reveal that fact.
@@ -54,13 +52,13 @@ export declare function getAbsolutePath(path: Nullish<PossiblePath>, base?: Abso
  * @param base Absolute path used for resolving relative paths in `possible`
  * @return Absolute path with a leading trailing slash, e.g. `/a/c/b`
  */
-export declare function requireAbsolutePath(path: AbsolutePath | RelativePath, base?: AbsolutePath, caller?: AnyCaller): AbsolutePath;
+export declare function requirePath(path: PossiblePath, base?: AbsolutePath, caller?: AnyCaller): AbsolutePath;
 /**
  * Match and strip a base path prefix from a path using segment-aware pathname rules.
  * - Both inputs must be absolute paths that begin with `/`.
  * - Returns `/` when the paths are an exact match.
  */
-export declare function matchPathPrefix(target: AbsolutePath | RelativePath, base: AbsolutePath, caller?: AnyCaller): AbsolutePath | undefined;
+export declare function matchPathPrefix(target: PossiblePath, base: PossiblePath, caller?: AnyCaller): AbsolutePath | undefined;
 /** Is a target path active? */
 export declare function isPathActive(target: AbsolutePath, current: AbsolutePath): boolean;
 /** Is a target path proud (i.e. is the current path, or is a child of the current path)? */

package/util/path.js

@@ -48,7 +48,7 @@ export function joinPath(...segments) {
  * @param base Absolute path used for resolving relative paths in `possible`
  * @return Absolute path with a leading slash but no trailing slash, e.g. `/a/c/b`
  */
-export function getAbsolutePath(path, base = "/") {
+export function getPath(path, base = "/") {
     if (!path)
         return;
     if (path === "/")
@@ -66,8 +66,8 @@ export function getAbsolutePath(path, base = "/") {
  * @param base Absolute path used for resolving relative paths in `possible`
  * @return Absolute path with a leading trailing slash, e.g. `/a/c/b`
  */
-export function requireAbsolutePath(path, base, caller = requireAbsolutePath) {
-    const output = getAbsolutePath(path, base);
+export function requirePath(path, base, caller = requirePath) {
+    const output = getPath(path, base);
     if (!output)
         throw new RequiredError("Invalid path", { received: path, caller });
     return output;
@@ -78,8 +78,8 @@ export function requireAbsolutePath(path, base, caller = requireAbsolutePath) {
  * - Returns `/` when the paths are an exact match.
  */
 export function matchPathPrefix(target, base, caller = matchPathPrefix) {
-    const basePath = requireAbsolutePath(base, undefined, caller);
-    const targetPath = requireAbsolutePath(target, basePath, caller);
+    const basePath = requirePath(base, undefined, caller);
+    const targetPath = requirePath(target, basePath, caller);
     if (basePath === "/")
         return targetPath;
     if (targetPath === basePath)