@jskit-ai/users-web 0.1.30 → 0.1.32

package/package.descriptor.mjs

@@ -1,7 +1,8 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-web",
-  version: "0.1.30",
+  version: "0.1.32",
+  kind: "runtime",
   description: "Users web module: workspace selector shell element plus workspace/profile/members UI elements.",
   dependsOn: [
     "@jskit-ai/http-runtime",
@@ -241,11 +242,11 @@ export default Object.freeze({
         "@uppy/dashboard": "^5.1.1",
         "@uppy/image-editor": "^4.2.0",
         "@uppy/xhr-upload": "^5.1.1",
-        "@jskit-ai/http-runtime": "0.1.16",
-        "@jskit-ai/realtime": "0.1.16",
-        "@jskit-ai/kernel": "0.1.17",
-        "@jskit-ai/shell-web": "0.1.16",
-        "@jskit-ai/users-core": "0.1.24",
+        "@jskit-ai/http-runtime": "0.1.17",
+        "@jskit-ai/realtime": "0.1.17",
+        "@jskit-ai/kernel": "0.1.18",
+        "@jskit-ai/shell-web": "0.1.17",
+        "@jskit-ai/users-core": "0.1.27",
         "vuetify": "^4.0.0"
       },
       dev: {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/users-web",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -9,8 +9,8 @@
     "./client": "./src/client/index.js",
     "./client/components/WorkspaceMembersClientElement": "./src/client/components/WorkspaceMembersClientElement.vue",
     "./client/composables/useAddEdit": "./src/client/composables/useAddEdit.js",
+    "./client/composables/useCrudSchemaForm": "./src/client/composables/useCrudSchemaForm.js",
     "./client/composables/useList": "./src/client/composables/useList.js",
-    "./client/composables/useCommand": "./src/client/composables/useCommand.js",
     "./client/composables/useView": "./src/client/composables/useView.js",
     "./client/composables/usePagedCollection": "./src/client/composables/usePagedCollection.js",
     "./client/composables/useAccountSettingsRuntime": "./src/client/composables/useAccountSettingsRuntime.js",
@@ -21,11 +21,11 @@
   "dependencies": {
     "@tanstack/vue-query": "5.92.12",
     "@mdi/js": "^7.4.47",
-    "@jskit-ai/users-core": "0.1.24",
-    "@jskit-ai/realtime": "0.1.16",
-    "@jskit-ai/http-runtime": "0.1.16",
-    "@jskit-ai/kernel": "0.1.17",
-    "@jskit-ai/shell-web": "0.1.16",
+    "@jskit-ai/users-core": "0.1.27",
+    "@jskit-ai/realtime": "0.1.17",
+    "@jskit-ai/http-runtime": "0.1.17",
+    "@jskit-ai/kernel": "0.1.18",
+    "@jskit-ai/shell-web": "0.1.17",
     "vuetify": "^4.0.0"
   }
 }

package/src/client/components/WorkspaceMembersClientElement.vue

@@ -32,11 +32,6 @@ import { useWorkspaceRouteContext } from "../composables/useWorkspaceRouteContex
 import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
 import { createWorkspaceRealtimeMatcher } from "../support/realtimeWorkspace.js";
 import { buildWorkspaceQueryKey } from "../support/workspaceQueryKeys.js";
-import {
-  WORKSPACE_SETTINGS_CHANGED_EVENT,
-  WORKSPACE_MEMBERS_CHANGED_EVENT,
-  WORKSPACE_INVITES_CHANGED_EVENT
-} from "@jskit-ai/users-core/shared/events/usersEvents";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
 
 const forms = reactive({
@@ -274,7 +269,7 @@ const workspaceSettingsView = useView({
     buildWorkspaceQueryKey("settings", surfaceId, workspaceSlug),
   viewPermissions: ["workspace.members.invite"],
   realtime: {
-    event: WORKSPACE_SETTINGS_CHANGED_EVENT,
+    event: "workspace.settings.changed",
     matches: matchesWorkspaceRealtime
   },
   fallbackLoadError: "Unable to load workspace settings."
@@ -295,7 +290,7 @@ const workspaceMembersList = useList({
     buildWorkspaceQueryKey("members", surfaceId, workspaceSlug),
   viewPermissions: ["workspace.members.view", "workspace.members.manage"],
   realtime: {
-    event: WORKSPACE_MEMBERS_CHANGED_EVENT,
+    event: "workspace.members.changed",
     matches: matchesWorkspaceRealtime
   },
   selectItems: (payload) => normalizeMembers(payload?.members),
@@ -309,7 +304,7 @@ const workspaceInvitesList = useList({
     buildWorkspaceQueryKey("invites", surfaceId, workspaceSlug),
   viewPermissions: ["workspace.members.view", "workspace.members.manage"],
   realtime: {
-    event: WORKSPACE_INVITES_CHANGED_EVENT,
+    event: "workspace.invites.changed",
     matches: matchesWorkspaceRealtime
   },
   selectItems: (payload) => normalizeInvites(payload?.invites),

package/src/client/components/WorkspaceSettingsFieldsClientElement.vue

@@ -170,7 +170,6 @@
 import { computed, reactive } from "vue";
 import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
 import { workspaceSettingsResource } from "@jskit-ai/users-core/shared/resources/workspaceSettingsResource";
-import { WORKSPACE_SETTINGS_CHANGED_EVENT } from "@jskit-ai/users-core/shared/events/usersEvents";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
 import {
   DEFAULT_WORKSPACE_DARK_PALETTE,
@@ -221,7 +220,7 @@ const addEdit = useAddEdit({
     "darkSurfaceVariantColor"
   ],
   realtime: {
-    event: WORKSPACE_SETTINGS_CHANGED_EVENT,
+    event: "workspace.settings.changed",
     matches: matchesWorkspaceRealtime
   },
   model: workspaceSettingsForm,

package/src/client/components/WorkspacesClientElement.vue

@@ -12,11 +12,6 @@ import { useView } from "../composables/useView.js";
 import { usePaths } from "../composables/usePaths.js";
 import { useRealtimeQueryInvalidation } from "../composables/useRealtimeQueryInvalidation.js";
 import { useWorkspaceSurfaceId } from "../composables/useWorkspaceSurfaceId.js";
-import {
-  WORKSPACE_SETTINGS_CHANGED_EVENT,
-  WORKSPACES_CHANGED_EVENT,
-  WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT
-} from "@jskit-ai/users-core/shared/events/usersEvents";
 import { USERS_ROUTE_VISIBILITY_PUBLIC } from "@jskit-ai/users-core/shared/support/usersVisibility";
 import { normalizePendingInvite } from "../composables/accountSettingsRuntimeHelpers.js";
 
@@ -55,7 +50,7 @@ const bootstrapView = useView({
   apiSuffix: "/bootstrap",
   queryKeyFactory: () => bootstrapQueryKey,
   realtime: {
-    event: WORKSPACE_SETTINGS_CHANGED_EVENT
+    event: "workspace.settings.changed"
   },
   fallbackLoadError: "Unable to load workspaces.",
   model: bootstrapModel,
@@ -112,12 +107,12 @@ const createWorkspaceCommand = useCommand({
 });
 
 useRealtimeQueryInvalidation({
-  event: WORKSPACES_CHANGED_EVENT,
+  event: "workspaces.changed",
   queryKey: bootstrapQueryKey
 });
 
 useRealtimeQueryInvalidation({
-  event: WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT,
+  event: "workspace.invitations.pending.changed",
   queryKey: bootstrapQueryKey
 });
 

package/src/client/composables/addEditUiRuntime.js

@@ -0,0 +1,120 @@
+import { computed, unref } from "vue";
+import { asPlainObject } from "./scopeHelpers.js";
+import {
+  normalizeRouteParamName,
+  resolveRouteParamsSource,
+  resolveRoutePathnameSource,
+  resolveRouteTemplateLocation,
+  toRouteParamValue
+} from "./routeTemplateHelpers.js";
+
+function toResolvedRecordId({ routeParams, recordIdParam, routeRecordId }) {
+  const explicitRecordId = toRouteParamValue(
+    typeof routeRecordId === "function" ? routeRecordId() : unref(routeRecordId)
+  );
+  if (explicitRecordId) {
+    return explicitRecordId;
+  }
+
+  return toRouteParamValue(routeParams[recordIdParam]);
+}
+
+function resolveSavedRecordId(payload, saveRecordIdSelector) {
+  const sourcePayload = asPlainObject(payload);
+  if (typeof saveRecordIdSelector === "function") {
+    return toRouteParamValue(saveRecordIdSelector(sourcePayload));
+  }
+
+  return toRouteParamValue(sourcePayload.id);
+}
+
+function createAddEditUiRuntime({
+  recordIdParam = "recordId",
+  routeParams = null,
+  routePath = "",
+  routeRecordId = null,
+  apiUrlTemplate = "",
+  viewUrlTemplate = "",
+  listUrlTemplate = "",
+  saveRecordIdSelector = null
+} = {}) {
+  const normalizedRecordIdParam = normalizeRouteParamName(recordIdParam, {
+    context: "useAddEdit recordIdParam"
+  });
+  const normalizedApiUrlTemplate = String(apiUrlTemplate || "").trim();
+  const normalizedViewUrlTemplate = String(viewUrlTemplate || "").trim();
+  const normalizedListUrlTemplate = String(listUrlTemplate || "").trim();
+
+  function resolveTemplatePath(urlTemplate = "", extraParams = {}) {
+    const normalizedTemplate = String(urlTemplate || "").trim();
+    if (!normalizedTemplate) {
+      return "";
+    }
+
+    const currentRouteParams = resolveRouteParamsSource(routeParams);
+    const sourceParams = {
+      ...currentRouteParams,
+      ...asPlainObject(extraParams)
+    };
+    const resolvedRecordId = toRouteParamValue(sourceParams[normalizedRecordIdParam]) ||
+      toResolvedRecordId({
+        routeParams: currentRouteParams,
+        recordIdParam: normalizedRecordIdParam,
+        routeRecordId
+      });
+    sourceParams[normalizedRecordIdParam] = resolvedRecordId;
+
+    return resolveRouteTemplateLocation(normalizedTemplate, {
+      params: sourceParams,
+      currentPathname: resolveRoutePathnameSource(routePath)
+    });
+  }
+
+  const recordId = computed(() =>
+    toResolvedRecordId({
+      routeParams: resolveRouteParamsSource(routeParams),
+      recordIdParam: normalizedRecordIdParam,
+      routeRecordId
+    })
+  );
+
+  const apiSuffix = computed(() => resolveTemplatePath(normalizedApiUrlTemplate));
+  const listUrl = computed(() => resolveTemplatePath(normalizedListUrlTemplate));
+  const cancelUrl = computed(() => resolveTemplatePath(normalizedViewUrlTemplate) || listUrl.value);
+
+  function resolveParams(urlTemplate = "", extraParams = {}) {
+    return resolveTemplatePath(urlTemplate, extraParams);
+  }
+
+  function resolveViewUrl(recordIdLike = "") {
+    const targetRecordId = toRouteParamValue(recordIdLike);
+    if (!targetRecordId) {
+      return "";
+    }
+
+    return resolveTemplatePath(normalizedViewUrlTemplate, {
+      [normalizedRecordIdParam]: targetRecordId
+    });
+  }
+
+  function resolveSavedViewUrl(payload = {}) {
+    const targetRecordId = resolveSavedRecordId(payload, saveRecordIdSelector);
+    if (!targetRecordId) {
+      return "";
+    }
+
+    return resolveViewUrl(targetRecordId);
+  }
+
+  return Object.freeze({
+    recordId,
+    apiSuffix,
+    listUrl,
+    cancelUrl,
+    resolveParams,
+    resolveViewUrl,
+    resolveSavedViewUrl
+  });
+}
+
+export { createAddEditUiRuntime };

package/src/client/composables/crudSchemaFormHelpers.js

@@ -0,0 +1,152 @@
+import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
+import { asPlainObject } from "./scopeHelpers.js";
+
+function normalizeCrudFormFields(fields = []) {
+  const normalizedFields = [];
+  const seenKeys = new Set();
+  for (const field of Array.isArray(fields) ? fields : []) {
+    const source = asPlainObject(field);
+    const key = String(source.key || "").trim();
+    if (!key || seenKeys.has(key)) {
+      continue;
+    }
+
+    seenKeys.add(key);
+    normalizedFields.push({
+      ...source,
+      key
+    });
+  }
+
+  return Object.freeze(normalizedFields);
+}
+
+function resolveFormFieldType(field = {}) {
+  return String(field.type || "").trim().toLowerCase();
+}
+
+function resolveFormFieldInitialValue(field = {}) {
+  if (Object.prototype.hasOwnProperty.call(field, "initialValue")) {
+    return field.initialValue;
+  }
+  if (Object.prototype.hasOwnProperty.call(field, "defaultValue")) {
+    return field.defaultValue;
+  }
+
+  const fieldType = resolveFormFieldType(field);
+  if (fieldType === "boolean") {
+    return false;
+  }
+
+  return "";
+}
+
+function createCrudFormModel(fields = []) {
+  const model = {};
+  for (const field of normalizeCrudFormFields(fields)) {
+    model[field.key] = resolveFormFieldInitialValue(field);
+  }
+
+  return model;
+}
+
+function buildCrudFormPayload(fields = [], model = {}) {
+  const payload = {};
+  const sourceModel = asPlainObject(model);
+
+  for (const field of normalizeCrudFormFields(fields)) {
+    const fieldKey = field.key;
+    const fieldType = resolveFormFieldType(field);
+    const rawValue = sourceModel[fieldKey];
+
+    if (fieldType === "boolean") {
+      payload[fieldKey] = Boolean(rawValue);
+      continue;
+    }
+
+    if (fieldType === "integer" || fieldType === "number") {
+      const normalizedValue = String(rawValue ?? "").trim();
+      if (!normalizedValue) {
+        continue;
+      }
+
+      const parsedNumber = Number(normalizedValue);
+      payload[fieldKey] = Number.isFinite(parsedNumber)
+        ? (fieldType === "integer" ? Math.trunc(parsedNumber) : parsedNumber)
+        : rawValue;
+      continue;
+    }
+
+    if (rawValue == null) {
+      continue;
+    }
+
+    payload[fieldKey] = rawValue;
+  }
+
+  return payload;
+}
+
+function applyCrudPayloadToForm(fields = [], model = {}, payload = {}) {
+  const targetModel = asPlainObject(model);
+  const sourcePayload = asPlainObject(payload);
+  for (const field of normalizeCrudFormFields(fields)) {
+    const fieldKey = field.key;
+    const fieldType = resolveFormFieldType(field);
+    const rawValue = sourcePayload[fieldKey];
+
+    if (fieldType === "boolean") {
+      targetModel[fieldKey] = Boolean(rawValue);
+      continue;
+    }
+
+    if (fieldType === "integer" || fieldType === "number") {
+      targetModel[fieldKey] = rawValue == null ? "" : String(rawValue);
+      continue;
+    }
+
+    targetModel[fieldKey] = rawValue == null ? "" : String(rawValue);
+  }
+}
+
+function resolveCrudFieldErrors(fieldErrors = {}, fieldKey = "") {
+  const key = String(fieldKey || "").trim();
+  if (!key) {
+    return [];
+  }
+
+  const source = asPlainObject(fieldErrors);
+  const message = String(source[key] || "").trim();
+  if (!message) {
+    return [];
+  }
+
+  return [message];
+}
+
+function parseCrudResourceOperationInput({
+  resource = null,
+  operationName = "",
+  rawPayload = {},
+  context = {}
+} = {}) {
+  const normalizedOperationName = String(operationName || "").trim();
+  const operations = asPlainObject(asPlainObject(resource).operations);
+  const operation = asPlainObject(operations[normalizedOperationName]);
+
+  return validateOperationSection({
+    operation,
+    section: "bodyValidator",
+    value: rawPayload,
+    context
+  });
+}
+
+export {
+  normalizeCrudFormFields,
+  createCrudFormModel,
+  buildCrudFormPayload,
+  applyCrudPayloadToForm,
+  resolveCrudFieldErrors,
+  parseCrudResourceOperationInput
+};

package/src/client/composables/listUiRuntime.js

@@ -0,0 +1,111 @@
+import { computed } from "vue";
+import { asPlainObject } from "./scopeHelpers.js";
+import {
+  normalizeRouteParamName,
+  toRouteParamValue,
+  resolveRouteParamsSource,
+  resolveRoutePathnameSource,
+  resolveRouteTemplateLocation
+} from "./routeTemplateHelpers.js";
+
+function resolveRecordId(record, recordIdSelector) {
+  const item = asPlainObject(record);
+  if (typeof recordIdSelector === "function") {
+    return toRouteParamValue(recordIdSelector(item));
+  }
+
+  return toRouteParamValue(item.id);
+}
+
+function createListUiRuntime({
+  items,
+  isInitialLoading,
+  recordIdParam = "recordId",
+  recordIdSelector = null,
+  routeParams = null,
+  routePath = "",
+  viewUrlTemplate = "",
+  editUrlTemplate = ""
+} = {}) {
+  const normalizedRecordIdParam = normalizeRouteParamName(recordIdParam, {
+    context: "useList recordIdParam"
+  });
+  const normalizedViewUrlTemplate = String(viewUrlTemplate || "").trim();
+  const normalizedEditUrlTemplate = String(editUrlTemplate || "").trim();
+  const hasViewUrl = Boolean(normalizedViewUrlTemplate);
+  const hasEditUrl = Boolean(normalizedEditUrlTemplate);
+  const actionColumnCount = (hasViewUrl ? 1 : 0) + (hasEditUrl ? 1 : 0);
+  const normalizedItems = computed(() => (Array.isArray(items?.value) ? items.value : []));
+  const showListSkeleton = computed(() => Boolean(isInitialLoading?.value && normalizedItems.value.length < 1));
+
+  function resolveTemplatePath(urlTemplate = "", extraParams = {}) {
+    const normalizedTemplate = String(urlTemplate || "").trim();
+    if (!normalizedTemplate) {
+      return "";
+    }
+
+    return resolveRouteTemplateLocation(normalizedTemplate, {
+      params: {
+        ...resolveRouteParamsSource(routeParams),
+        ...asPlainObject(extraParams)
+      },
+      currentPathname: resolveRoutePathnameSource(routePath)
+    });
+  }
+
+  function resolveParams(urlTemplate = "", extraParams = {}) {
+    return resolveTemplatePath(urlTemplate, extraParams);
+  }
+
+  function resolveRowKey(record, index) {
+    const recordId = resolveRecordId(record, recordIdSelector);
+    if (recordId) {
+      return recordId;
+    }
+
+    return `row-${index}`;
+  }
+
+  function resolveViewUrl(record) {
+    if (!hasViewUrl) {
+      return "";
+    }
+
+    const recordId = resolveRecordId(record, recordIdSelector);
+    if (!recordId) {
+      return "";
+    }
+
+    return resolveTemplatePath(normalizedViewUrlTemplate, {
+      [normalizedRecordIdParam]: recordId
+    });
+  }
+
+  function resolveEditUrl(record) {
+    if (!hasEditUrl) {
+      return "";
+    }
+
+    const recordId = resolveRecordId(record, recordIdSelector);
+    if (!recordId) {
+      return "";
+    }
+
+    return resolveTemplatePath(normalizedEditUrlTemplate, {
+      [normalizedRecordIdParam]: recordId
+    });
+  }
+
+  return Object.freeze({
+    hasViewUrl,
+    hasEditUrl,
+    actionColumnCount,
+    showListSkeleton,
+    resolveParams,
+    resolveRowKey,
+    resolveViewUrl,
+    resolveEditUrl
+  });
+}
+
+export { createListUiRuntime };

package/src/client/composables/operationAdapters.js

@@ -0,0 +1,34 @@
+import { useOperationScope } from "./internal/useOperationScope.js";
+
+const USERS_OPERATION_ADAPTER_ID = "users-default";
+
+function createUsersOperationAdapter() {
+  return Object.freeze({
+    id: USERS_OPERATION_ADAPTER_ID,
+    useOperationScope(options = {}) {
+      return useOperationScope(options);
+    }
+  });
+}
+
+const defaultUsersOperationAdapter = createUsersOperationAdapter();
+
+function resolveOperationAdapter(adapter, { context = "users-web operation adapter" } = {}) {
+  if (adapter == null) {
+    return defaultUsersOperationAdapter;
+  }
+
+  if (!adapter || typeof adapter !== "object" || Array.isArray(adapter)) {
+    throw new TypeError(`${context} must be an object when provided.`);
+  }
+  if (typeof adapter.useOperationScope !== "function") {
+    throw new TypeError(`${context} must expose useOperationScope(options).`);
+  }
+
+  return adapter;
+}
+
+export {
+  createUsersOperationAdapter,
+  resolveOperationAdapter
+};

package/src/client/composables/routeTemplateHelpers.js

@@ -0,0 +1,110 @@
+import { unref } from "vue";
+import { asPlainObject } from "./scopeHelpers.js";
+
+const ROUTE_PARAM_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+
+function normalizeRouteParamName(value = "", { context = "users-web route param" } = {}) {
+  const normalizedValue = String(value || "").trim();
+  if (!normalizedValue) {
+    throw new TypeError(`${context} must be a non-empty route parameter name.`);
+  }
+  if (!ROUTE_PARAM_NAME_PATTERN.test(normalizedValue)) {
+    throw new TypeError(
+      `${context} "${normalizedValue}" is invalid. Use letters, numbers, and underscores only.`
+    );
+  }
+
+  return normalizedValue;
+}
+
+function toRouteParamValue(value) {
+  if (Array.isArray(value)) {
+    return toRouteParamValue(value[0]);
+  }
+  if (value == null) {
+    return "";
+  }
+
+  return String(value).trim();
+}
+
+function resolveRouteSourceValue(source = null) {
+  if (typeof source === "function") {
+    return source();
+  }
+
+  return unref(source);
+}
+
+function resolveRouteParamsSource(source = null) {
+  return asPlainObject(resolveRouteSourceValue(source));
+}
+
+function normalizeRoutePathname(value = "") {
+  const rawPathname = String(value || "").trim();
+  const sanitizedPathname = rawPathname.split(/[?#]/u, 1)[0] || "";
+  if (!sanitizedPathname) {
+    return "/";
+  }
+
+  return sanitizedPathname.startsWith("/") ? sanitizedPathname : `/${sanitizedPathname}`;
+}
+
+function resolveRoutePathnameSource(source = "") {
+  return normalizeRoutePathname(resolveRouteSourceValue(source));
+}
+
+function resolveRouteTemplatePath(routeTemplate = "", params = {}) {
+  const normalizedTemplate = String(routeTemplate || "").trim();
+  if (!normalizedTemplate) {
+    return "";
+  }
+
+  const source = asPlainObject(params);
+  const missingParams = [];
+  const resolvedPath = normalizedTemplate.replace(/:([A-Za-z][A-Za-z0-9_]*)/g, (_, key) => {
+    const value = toRouteParamValue(source[key]);
+    if (!value) {
+      missingParams.push(key);
+      return `:${key}`;
+    }
+
+    return encodeURIComponent(value);
+  });
+
+  if (missingParams.length > 0) {
+    return "";
+  }
+
+  return resolvedPath;
+}
+
+function resolveRouteTemplateLocation(routeTemplate = "", { params = {}, currentPathname = "/" } = {}) {
+  const resolvedTemplatePath = resolveRouteTemplatePath(routeTemplate, params);
+  if (!resolvedTemplatePath) {
+    return "";
+  }
+  if (resolvedTemplatePath.startsWith("/")) {
+    return resolvedTemplatePath;
+  }
+
+  const normalizedCurrentPathname = resolveRoutePathnameSource(currentPathname);
+  const basePathname = normalizedCurrentPathname.endsWith("/")
+    ? normalizedCurrentPathname
+    : `${normalizedCurrentPathname}/`;
+  const resolvedPathname = new URL(resolvedTemplatePath, `https://jskit.local${basePathname}`).pathname;
+  if (resolvedPathname.length > 1 && resolvedPathname.endsWith("/")) {
+    return resolvedPathname.slice(0, -1);
+  }
+
+  return resolvedPathname;
+}
+
+export {
+  normalizeRouteParamName,
+  toRouteParamValue,
+  resolveRouteParamsSource,
+  resolveRoutePathnameSource,
+  resolveRouteTemplatePath,
+  resolveRouteTemplateLocation
+};