@jskit-ai/users-web 0.1.37 → 0.1.38

package/src/client/composables/internal/crudListParentTitleSupport.js

@@ -0,0 +1,168 @@
+import {
+  normalizeCrudLookupContainerKey,
+  resolveCrudLookupApiPathFromNamespace,
+  resolveCrudLookupFieldKeyFromRouteParam
+} from "@jskit-ai/kernel/shared/support/crudLookup";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveLookupFieldDisplayValue, resolveRecordTitle } from "../crud/crudLookupFieldLabelSupport.js";
+import { resolveRouteParamNamesInOrder, toRouteParamValue } from "../support/routeTemplateHelpers.js";
+
+function singularizeLabel(value = "") {
+  const normalizedValue = normalizeText(value);
+  if (!normalizedValue) {
+    return "";
+  }
+  if (normalizedValue.endsWith("ies")) {
+    return `${normalizedValue.slice(0, -3)}y`;
+  }
+  if (normalizedValue.endsWith("s") && !normalizedValue.endsWith("ss")) {
+    return normalizedValue.slice(0, -1);
+  }
+  return normalizedValue;
+}
+
+function toTitleLabel(value = "") {
+  const normalizedValue = normalizeText(value)
+    .replace(/Id$/u, "")
+    .replace(/[_-]+/gu, " ")
+    .replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+    .trim();
+  if (!normalizedValue) {
+    return "";
+  }
+
+  return normalizedValue
+    .split(/\s+/u)
+    .filter(Boolean)
+    .map((entry) => entry.charAt(0).toUpperCase() + entry.slice(1))
+    .join(" ");
+}
+
+function resolveEntityLabel(routeParamKey = "", relationNamespace = "") {
+  const routeLabel = singularizeLabel(toTitleLabel(routeParamKey));
+  if (routeLabel) {
+    return routeLabel;
+  }
+
+  const namespaceLabel = singularizeLabel(toTitleLabel(relationNamespace));
+  if (namespaceLabel) {
+    return namespaceLabel;
+  }
+
+  return "Record";
+}
+
+function resolveLookupFieldMeta(resource = {}, fieldKey = "") {
+  const normalizedFieldKey = normalizeText(fieldKey);
+  if (!normalizedFieldKey) {
+    return null;
+  }
+
+  const entries = Array.isArray(resource?.fieldMeta) ? resource.fieldMeta : [];
+  for (const entry of entries) {
+    if (normalizeText(entry?.key) !== normalizedFieldKey) {
+      continue;
+    }
+
+    const relation = entry?.relation;
+    if (!relation || normalizeText(relation.kind).toLowerCase() !== "lookup") {
+      return null;
+    }
+
+    return entry;
+  }
+
+  return null;
+}
+
+function resolveCrudListParentDescriptor({ resource = {}, route = null, recordIdParam = "recordId" } = {}) {
+  const orderedRouteParamNames = resolveRouteParamNamesInOrder(route);
+  if (orderedRouteParamNames.length < 1) {
+    return null;
+  }
+
+  const normalizedRecordIdParam = normalizeText(recordIdParam) || "recordId";
+  for (const routeParamKey of [...orderedRouteParamNames].reverse()) {
+    if (routeParamKey === "workspaceSlug" || routeParamKey === normalizedRecordIdParam) {
+      continue;
+    }
+
+    const fieldKey = resolveCrudLookupFieldKeyFromRouteParam(resource, routeParamKey);
+    if (!fieldKey) {
+      continue;
+    }
+
+    const fieldMeta = resolveLookupFieldMeta(resource, fieldKey);
+    if (!fieldMeta) {
+      continue;
+    }
+
+    const relation = fieldMeta.relation || {};
+    const relationNamespace = normalizeText(relation.namespace);
+    const containerKey = normalizeCrudLookupContainerKey(relation.containerKey, {
+      defaultValue: resource?.contract?.lookup?.containerKey || "lookups"
+    });
+
+    return Object.freeze({
+      fieldKey,
+      routeParamKey,
+      relationNamespace,
+      entityLabel: resolveEntityLabel(routeParamKey, relationNamespace),
+      labelKey: normalizeText(relation.labelKey),
+      fieldDescriptor: Object.freeze({
+        key: fieldKey,
+        relation: Object.freeze({
+          kind: "lookup",
+          valueKey: normalizeText(relation.valueKey) || "id",
+          labelKey: normalizeText(relation.labelKey),
+          containerKey
+        })
+      }),
+      apiUrlTemplate: relationNamespace
+        ? `${resolveCrudLookupApiPathFromNamespace(relationNamespace)}/:${routeParamKey}`
+        : ""
+    });
+  }
+
+  return null;
+}
+
+function resolveCrudListParentTitleFromItems(items = [], descriptor = null) {
+  const sourceItems = Array.isArray(items) ? items : [];
+  if (!descriptor?.fieldDescriptor) {
+    return "";
+  }
+
+  for (const item of sourceItems) {
+    const resolvedTitle = normalizeText(resolveLookupFieldDisplayValue(item, descriptor.fieldDescriptor));
+    if (resolvedTitle) {
+      return resolvedTitle;
+    }
+  }
+
+  return "";
+}
+
+function resolveCrudListParentRecordTitle(record = {}, descriptor = null) {
+  const resolvedTitle = resolveRecordTitle(record, {
+    fallbackKey: normalizeText(descriptor?.labelKey),
+    defaultValue: ""
+  });
+  if (resolvedTitle && resolvedTitle !== "-") {
+    return resolvedTitle;
+  }
+
+  const entityLabel = normalizeText(descriptor?.entityLabel) || "Record";
+  const recordId = toRouteParamValue(record?.id);
+  if (recordId) {
+    return `${entityLabel} #${recordId}`;
+  }
+
+  return "";
+}
+
+export {
+  resolveCrudListParentDescriptor,
+  resolveCrudListParentRecordTitle,
+  resolveCrudListParentTitleFromItems
+};

package/src/client/composables/internal/useOperationScope.js

@@ -7,7 +7,7 @@ import {
   resolvePermissionAccess,
   resolveEnabled,
   resolveQueryKey
-} from "../scopeHelpers.js";
+} from "../support/scopeHelpers.js";
 
 function normalizePermissionSets(permissionSets = {}) {
   const source = permissionSets && typeof permissionSets === "object" && !Array.isArray(permissionSets)

package/src/client/composables/{useAddEdit.js → records/useAddEdit.js}

@@ -1,20 +1,20 @@
 import { computed, proxyRefs } from "vue";
 import { useRoute } from "vue-router";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
-import { useAddEditCore } from "./useAddEditCore.js";
-import { useEndpointResource } from "./useEndpointResource.js";
-import { resolveOperationAdapter } from "./operationAdapters.js";
-import { createAddEditUiRuntime } from "./addEditUiRuntime.js";
-import { useUiFeedback } from "./useUiFeedback.js";
-import { useFieldErrorBag } from "./useFieldErrorBag.js";
+import { useAddEditCore } from "../runtime/useAddEditCore.js";
+import { useEndpointResource } from "../runtime/useEndpointResource.js";
+import { resolveOperationAdapter } from "../runtime/operationAdapters.js";
+import { createAddEditUiRuntime } from "../runtime/addEditUiRuntime.js";
+import { useUiFeedback } from "../runtime/useUiFeedback.js";
+import { useFieldErrorBag } from "../runtime/useFieldErrorBag.js";
 import {
   setupRouteChangeCleanup,
   setupOperationErrorReporting
-} from "./operationUiHelpers.js";
+} from "../runtime/operationUiHelpers.js";
 import {
   resolveResourceMessages
-} from "./scopeHelpers.js";
-import { resolveRouteParamNamesInOrder } from "./routeTemplateHelpers.js";
+} from "../support/scopeHelpers.js";
+import { resolveRouteParamNamesInOrder } from "../support/routeTemplateHelpers.js";
 
 function useAddEdit({
   ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,

package/src/client/composables/{useCrudSchemaForm.js → records/useCrudAddEdit.js}

@@ -1,17 +1,20 @@
 import { computed, proxyRefs, reactive, watch } from "vue";
 import { useRoute, useRouter } from "vue-router";
-import { asPlainObject } from "./scopeHelpers.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
 import { useAddEdit } from "./useAddEdit.js";
+import {
+  resolveCrudBoundValues,
+} from "../crud/crudBindingSupport.js";
 import {
   normalizeCrudFormFields,
   createCrudFormModel,
   buildCrudFormPayload,
   applyCrudPayloadToForm,
-  applyCrudRouteBoundFieldValues,
+  resolveCrudRouteBoundFieldValues,
   resolveCrudFieldErrors,
   parseCrudResourceOperationInput
-} from "./crudSchemaFormHelpers.js";
-import { hasResolvedQueryData } from "./resourceLoadStateHelpers.js";
+} from "../crud/crudSchemaFormHelpers.js";
+import { hasResolvedQueryData } from "../support/resourceLoadStateHelpers.js";
 
 function normalizeFieldErrorKeys(keys = []) {
   return Array.isArray(keys)
@@ -36,12 +39,13 @@ function normalizeSaveSuccessOptions(options = {}) {
   });
 }
 
-function useCrudSchemaForm({
+function useCrudAddEdit({
   resource = null,
   operationName = "",
   formFields = [],
   addEditOptions = {},
   saveSuccess = {},
+  fieldBinding = null,
   createModel = null,
   buildPayload = null,
   mapPayloadToModel = null,
@@ -61,18 +65,31 @@ function useCrudSchemaForm({
     ? asPlainObject(createModel(normalizedFields))
     : createCrudFormModel(normalizedFields);
   const form = hasProvidedModel ? providedModel : reactive(defaultModel);
+  const boundFieldValues = computed(() => {
+    return resolveCrudBoundValues({
+      binding: fieldBinding,
+      routeValues: resolveCrudRouteBoundFieldValues(normalizedFields, route?.params || {}),
+      context: Object.freeze({
+        route,
+        fields: normalizedFields
+      })
+    });
+  });
 
-  function applyRouteBoundValues(target = {}) {
-    return applyCrudRouteBoundFieldValues(normalizedFields, target, route?.params || {});
+  function applyBoundFieldValues(target = {}) {
+    Object.assign(target, boundFieldValues.value);
+    return target;
   }
 
-  applyRouteBoundValues(form);
   watch(
-    () => route?.params,
+    boundFieldValues,
     () => {
-      applyRouteBoundValues(form);
+      applyBoundFieldValues(form);
     },
-    { deep: true }
+    {
+      immediate: true,
+      deep: true
+    }
   );
   const parseInputOverride = typeof parseInput === "function"
     ? parseInput
@@ -109,7 +126,7 @@ function useCrudSchemaForm({
           fields: normalizedFields
         })
       : buildCrudFormPayload(normalizedFields, model);
-    applyRouteBoundValues(payload);
+    applyBoundFieldValues(payload);
 
     return payload;
   }
@@ -120,12 +137,12 @@ function useCrudSchemaForm({
           ...context,
           fields: normalizedFields
         });
-        applyRouteBoundValues(model);
+        applyBoundFieldValues(model);
       }
     : (shouldApplyDefaultMapPayload
         ? (model = {}, payload = {}) => {
             applyCrudPayloadToForm(normalizedFields, model, payload);
-            applyRouteBoundValues(model);
+            applyBoundFieldValues(model);
           }
         : undefined);
 
@@ -200,4 +217,4 @@ function useCrudSchemaForm({
   });
 }
 
-export { useCrudSchemaForm };
+export { useCrudAddEdit };

package/src/client/composables/records/useCrudList.js

@@ -0,0 +1,83 @@
+import { computed, unref } from "vue";
+import { useRoute } from "vue-router";
+import { resolveLookupFieldDisplayValue } from "../crud/crudLookupFieldLabelSupport.js";
+import { resolveCrudBoundValues } from "../crud/crudBindingSupport.js";
+import { resolveCrudListParentDescriptor } from "../internal/crudListParentTitleSupport.js";
+import {
+  resolveRouteParamsSource,
+  toRouteParamValue
+} from "../support/routeTemplateHelpers.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
+import { useList } from "./useList.js";
+
+function resolveRequestQueryParamsInput(requestQueryParams, context = {}) {
+  if (typeof requestQueryParams === "function") {
+    return asPlainObject(requestQueryParams(context));
+  }
+
+  return asPlainObject(unref(requestQueryParams));
+}
+
+function resolveCrudParentRequestQueryParams({ resource = {}, route = null, recordIdParam = "recordId" } = {}) {
+  const descriptor = resolveCrudListParentDescriptor({
+    resource,
+    route,
+    recordIdParam
+  });
+  if (!descriptor?.fieldKey || !descriptor?.routeParamKey) {
+    return {};
+  }
+
+  const routeParams = resolveRouteParamsSource(route?.params || {});
+  const routeParamValue = toRouteParamValue(routeParams[descriptor.routeParamKey]);
+  if (!routeParamValue) {
+    return {};
+  }
+
+  return {
+    [descriptor.fieldKey]: routeParamValue
+  };
+}
+
+function useCrudList({
+  resource = null,
+  requestQueryParams = null,
+  parentBinding = null,
+  recordIdParam = "recordId",
+  route = null,
+  ...listOptions
+} = {}) {
+  const sourceRoute = route && typeof route === "object" ? route : useRoute();
+  const boundParentRequestQueryParams = computed(() => {
+    return resolveCrudBoundValues({
+      binding: parentBinding,
+      routeValues: resolveCrudParentRequestQueryParams({
+        resource,
+        route: sourceRoute,
+        recordIdParam
+      }),
+      context: Object.freeze({
+        route: sourceRoute,
+        resource,
+        recordIdParam
+      })
+    });
+  });
+  const records = useList({
+    ...listOptions,
+    recordIdParam,
+    requestQueryParams(context = {}) {
+      const baseRequestQueryParams = resolveRequestQueryParamsInput(requestQueryParams, context);
+
+      return {
+        ...baseRequestQueryParams,
+        ...boundParentRequestQueryParams.value
+      };
+    }
+  });
+
+  records.resolveFieldDisplay = resolveLookupFieldDisplayValue;
+  return records;
+}
+
+export { useCrudList };

package/src/client/composables/records/useCrudView.js

@@ -0,0 +1,35 @@
+import { computed } from "vue";
+import { useRoute } from "vue-router";
+import {
+  resolveLookupFieldDisplayValue,
+  resolveRecordTitle
+} from "../crud/crudLookupFieldLabelSupport.js";
+import { resolveCrudBoundValues } from "../crud/crudBindingSupport.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
+import { useView } from "./useView.js";
+
+function useCrudView({
+  paramBinding = null,
+  route = null,
+  ...viewOptions
+} = {}) {
+  const sourceRoute = route && typeof route === "object" ? route : useRoute();
+  const boundRouteParams = computed(() => {
+    return resolveCrudBoundValues({
+      binding: paramBinding,
+      routeValues: asPlainObject(sourceRoute?.params || {}),
+      context: Object.freeze({
+        route: sourceRoute
+      })
+    });
+  });
+  const view = useView({
+    ...viewOptions,
+    routeParams: boundRouteParams
+  });
+  view.resolveFieldDisplay = resolveLookupFieldDisplayValue;
+  view.resolveRecordTitle = resolveRecordTitle;
+  return view;
+}
+
+export { useCrudView };

package/src/client/composables/{useList.js → records/useList.js}

@@ -2,17 +2,16 @@ import { computed, onScopeDispose, proxyRefs, ref, watch } from "vue";
 import { useRouter } from "vue-router";
 import { appendQueryString } from "@jskit-ai/kernel/shared/support";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveCrudLookupFieldKeys } from "@jskit-ai/kernel/shared/support/crudLookup";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
-import { useListCore } from "./useListCore.js";
-import { resolveOperationAdapter } from "./operationAdapters.js";
-import { setupOperationErrorReporting } from "./operationUiHelpers.js";
-import { createListUiRuntime } from "./listUiRuntime.js";
-import { asPlainObject } from "./scopeHelpers.js";
+import { useListCore } from "../runtime/useListCore.js";
+import { resolveOperationAdapter } from "../runtime/operationAdapters.js";
+import { setupOperationErrorReporting } from "../runtime/operationUiHelpers.js";
+import { createListUiRuntime } from "../runtime/listUiRuntime.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
 import {
   normalizeListSearchConfig,
   matchesLocalSearch
-} from "./listSearchSupport.js";
+} from "../support/listSearchSupport.js";
 import {
   normalizeListSyncToRouteConfig,
   resolveQueryParamDescriptors,
@@ -24,13 +23,10 @@ import {
   buildRouteQueryCompareToken,
   mergeManagedQueryParamKeyHistory,
   resolveRouteSyncManagedKeys
-} from "./listQueryParamSupport.js";
-import { resolveLookupFieldDisplayValue } from "./crudLookupFieldLabelSupport.js";
+} from "../support/listQueryParamSupport.js";
 import {
   resolveRouteParamNamesInOrder,
-  resolveRouteParamsSource,
-  toRouteParamValue
-} from "./routeTemplateHelpers.js";
+} from "../support/routeTemplateHelpers.js";
 
 const EMPTY_ROUTE_SYNC_QUERY_PARAM_BLACKLIST = Object.freeze([]);
 
@@ -51,13 +47,13 @@ function useList({
   queryOptions,
   realtime = null,
   adapter = null,
-  resource = null,
   recordIdParam = "recordId",
   recordIdSelector = null,
   viewUrlTemplate = "",
   editUrlTemplate = "",
   search = null,
   queryParams = null,
+  requestQueryParams = null,
   syncToRoute = false
 } = {}) {
   const searchConfig = normalizeListSearchConfig(search);
@@ -142,52 +138,25 @@ function useList({
   const queryParamDescriptors = computed(() => {
     return resolveQueryParamDescriptors(queryParams, queryParamsContext.value);
   });
+  const requestQueryParamDescriptors = computed(() => {
+    return resolveQueryParamDescriptors(requestQueryParams, queryParamsContext.value);
+  });
   const declaredQueryParamKeys = computed(() => {
     return queryParamDescriptors.value.map((descriptor) => descriptor.key);
   });
   const activeQueryParamEntries = computed(() => {
     return resolveActiveQueryParamEntries(queryParamDescriptors.value);
   });
+  const activeRequestQueryParamEntries = computed(() => {
+    return resolveActiveQueryParamEntries(requestQueryParamDescriptors.value);
+  });
   const activeQueryParamsToken = computed(() => buildQueryParamEntriesToken(activeQueryParamEntries.value));
+  const activeRequestQueryParamsToken = computed(() => {
+    return buildQueryParamEntriesToken(activeRequestQueryParamEntries.value);
+  });
   const writableQueryParamBindings = computed(() => {
     return resolveWritableQueryParamBindings(queryParamDescriptors.value);
   });
-  const parentRouteFilter = computed(() => {
-    const lookupFieldKeys = resolveCrudLookupFieldKeys(resource);
-    if (lookupFieldKeys.length < 1) {
-      return null;
-    }
-
-    const lookupFieldKeySet = new Set(lookupFieldKeys);
-    const sourceRoute = operationScope.routeContext.route;
-    const orderedRouteParamNames = resolveRouteParamNamesInOrder(sourceRoute);
-    if (orderedRouteParamNames.length < 1) {
-      return null;
-    }
-
-    const normalizedRecordIdParam = normalizeText(recordIdParam) || "recordId";
-    const parentParamName = [...orderedRouteParamNames]
-      .reverse()
-      .find((name) => (
-        name !== "workspaceSlug" &&
-        name !== normalizedRecordIdParam &&
-        lookupFieldKeySet.has(name)
-      )) || "";
-    if (!parentParamName) {
-      return null;
-    }
-
-    const routeParams = resolveRouteParamsSource(sourceRoute?.params || {});
-    const parentParamValue = toRouteParamValue(routeParams[parentParamName]);
-    if (!parentParamValue) {
-      return null;
-    }
-
-    return Object.freeze({
-      key: parentParamName,
-      value: parentParamValue
-    });
-  });
   const activeSearchQuery = computed(() => {
     if (searchConfig.enabled !== true) {
       return "";
@@ -213,11 +182,11 @@ function useList({
       }
     }
 
-    const parentFilter = parentRouteFilter.value;
-    if (parentFilter) {
-      searchParams.set(parentFilter.key, parentFilter.value);
+    for (const entry of activeRequestQueryParamEntries.value) {
+      for (const value of entry.values) {
+        searchParams.append(entry.key, value);
+      }
     }
-
     for (const entry of activeQueryParamEntries.value) {
       for (const value of entry.values) {
         searchParams.append(entry.key, value);
@@ -238,9 +207,8 @@ function useList({
       : sourceQueryKey == null
         ? []
         : [sourceQueryKey];
-    const parentFilter = parentRouteFilter.value;
-    if (parentFilter) {
-      baseQueryKey.push("__parent__", parentFilter.key, parentFilter.value);
+    if (activeRequestQueryParamsToken.value) {
+      baseQueryKey.push("__request_query__", activeRequestQueryParamsToken.value);
     }
     if (querySearchEnabled.value) {
       baseQueryKey.push("__search__", searchConfig.queryParam, activeSearchQuery.value);
@@ -430,6 +398,13 @@ function useList({
 
     list.trimToFirstPage();
   });
+  watch(activeRequestQueryParamsToken, (nextValue, previousValue) => {
+    if (nextValue === previousValue) {
+      return;
+    }
+
+    list.trimToFirstPage();
+  });
   const filteredItems = computed(() => {
     const sourceItems = Array.isArray(list.items.value) ? list.items.value : [];
     if (searchConfig.enabled !== true || searchConfig.mode !== "local") {
@@ -494,7 +469,6 @@ function useList({
     resolveParams: listUiRuntime.resolveParams,
     resolveViewUrl: listUiRuntime.resolveViewUrl,
     resolveEditUrl: listUiRuntime.resolveEditUrl,
-    resolveFieldDisplay: resolveLookupFieldDisplayValue,
     searchEnabled: searchConfig.enabled,
     searchMode: searchConfig.mode,
     searchQuery,

package/src/client/composables/{useView.js → records/useView.js}

@@ -1,13 +1,12 @@
 import { computed, proxyRefs } from "vue";
 import { useRoute } from "vue-router";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
-import { useViewCore } from "./useViewCore.js";
-import { useEndpointResource } from "./useEndpointResource.js";
-import { resolveOperationAdapter } from "./operationAdapters.js";
-import { setupOperationErrorReporting } from "./operationUiHelpers.js";
-import { createViewUiRuntime } from "./viewUiRuntime.js";
-import { resolveLookupFieldDisplayValue, resolveRecordTitle } from "./crudLookupFieldLabelSupport.js";
-import { resolveRouteParamNamesInOrder } from "./routeTemplateHelpers.js";
+import { useViewCore } from "../runtime/useViewCore.js";
+import { useEndpointResource } from "../runtime/useEndpointResource.js";
+import { resolveOperationAdapter } from "../runtime/operationAdapters.js";
+import { setupOperationErrorReporting } from "../runtime/operationUiHelpers.js";
+import { createViewUiRuntime } from "../runtime/viewUiRuntime.js";
+import { resolveRouteParamNamesInOrder } from "../support/routeTemplateHelpers.js";
 
 function useView({
   ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,
@@ -115,8 +114,6 @@ function useView({
     listUrl: viewUiRuntime.listUrl,
     editUrl: viewUiRuntime.editUrl,
     resolveParams: viewUiRuntime.resolveParams,
-    resolveFieldDisplay: resolveLookupFieldDisplayValue,
-    resolveRecordTitle,
     canView,
     isLoading,
     isFetching,

package/src/client/composables/{addEditUiRuntime.js → runtime/addEditUiRuntime.js}

@@ -1,12 +1,12 @@
 import { computed, unref } from "vue";
-import { asPlainObject } from "./scopeHelpers.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
 import {
   normalizeRouteParamName,
   resolveRouteParamsSource,
   resolveScopedRoutePathname,
   resolveRouteTemplateLocation,
   toRouteParamValue
-} from "./routeTemplateHelpers.js";
+} from "../support/routeTemplateHelpers.js";
 
 function toResolvedRecordId({ routeParams, recordIdParam, routeRecordId }) {
   const explicitRecordId = toRouteParamValue(

package/src/client/composables/{listUiRuntime.js → runtime/listUiRuntime.js}

@@ -1,12 +1,12 @@
 import { computed } from "vue";
-import { asPlainObject } from "./scopeHelpers.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
 import {
   normalizeRouteParamName,
   toRouteParamValue,
   resolveRouteParamsSource,
   resolveScopedRoutePathname,
   resolveRouteTemplateLocation
-} from "./routeTemplateHelpers.js";
+} from "../support/routeTemplateHelpers.js";
 
 function resolveRecordId(record, recordIdSelector) {
   const item = asPlainObject(record);

package/src/client/composables/{operationAdapters.js → runtime/operationAdapters.js}

@@ -1,4 +1,4 @@
-import { useOperationScope } from "./internal/useOperationScope.js";
+import { useOperationScope } from "../internal/useOperationScope.js";
 
 const USERS_OPERATION_ADAPTER_ID = "users-default";