@stackbit/cms-sanity 0.2.45-develop.1 → 0.2.45-staging.1

package/src/utils.ts

@@ -1,5 +1,7 @@
 import _ from 'lodash';
 import { Field } from '@stackbit/types';
+import * as StackbitTypes from '@stackbit/types';
+import { ModelWithContext } from './sanity-schema-converter';
 
 export function resolveLabelFieldForModel(model: any, modelLabelFieldPath: string, fields: Field[]): string {
     let labelField = _.get(model, modelLabelFieldPath, null);
@@ -21,3 +23,99 @@ export function resolveLabelFieldForModel(model: any, modelLabelFieldPath: strin
     }
     return labelField || null;
 }
+
+export function getSanityAliasFieldType({ resolvedType, model, modelFieldPath }: { resolvedType: string; model: ModelWithContext; modelFieldPath: string[] }) {
+    const fieldAlias = model.context?.fieldAliasMap?.[modelFieldPath.join('.')] ?? [];
+    return fieldAlias?.find((alias) => alias.resolvedTypeName === resolvedType)?.origTypeName ?? resolvedType;
+}
+
+export function resolvedFieldType({ sanityFieldType, model, modelFieldPath }: { sanityFieldType: string; model: ModelWithContext; modelFieldPath: string[] }) {
+    const fieldAlias = model.context?.fieldAliasMap?.[modelFieldPath.join('.')] ?? [];
+    return fieldAlias?.find((alias) => alias.origTypeName === sanityFieldType)?.resolvedTypeName ?? sanityFieldType;
+}
+
+export function isLocalizedModelField(modelField: StackbitTypes.Field | StackbitTypes.FieldListItems) {
+    return 'localized' in modelField && modelField.localized;
+}
+
+export interface FieldListMultiItem {
+    type: 'list';
+    items: StackbitTypes.FieldListItems | StackbitTypes.FieldListItems[];
+}
+
+/**
+ * Sanity 'Array' field type can hold multiple field types.
+ *
+ * For example, Sanity Arrays can simultaneously include items of `model`
+ * and `reference` types. https://www.sanity.io/docs/array-type#wT47gyCx
+ *
+ * With that, Sanity Arrays cannot include both primitive and complex types:
+ * https://www.sanity.io/docs/array-type#fNBIr84P
+ *
+ * TODO:
+ * This is not yet supported by Stackbit's TypeScript types, so the `any`
+ * must be used. Additionally, if a Sanity array has multiple types of items one
+ * of which is the 'object' type, then it will also have the 'name' property to
+ * allow matching 'object' items to their types. The 'name' property is not
+ * supported in Stackbit list items, so '@ts-ignore' is used.
+ *
+ * However, Stackbit client app should be able to render this types of lists correctly.
+ *
+ * @example A list that can include items of type 'model', 'reference' and 'object'.
+ * {
+ *     type: 'list',
+ *     items: [{
+ *         type: 'model',
+ *         models: [...]
+ *     }, {
+ *         type: 'reference',
+ *         models: [...]
+ *     }, {
+ *         type: 'object',
+ *         name: 'nested_object_name',
+ *         fields: {...}
+ *     }]
+ * }
+ */
+export function getItemTypeForListItem(listItem: any, fieldModel: FieldListMultiItem): StackbitTypes.FieldListItems | null {
+    const itemModels = fieldModel.items ?? { type: 'string' };
+    // in Sanity, list items may have multiple types, in this case, 'items' will be an array
+    if (!_.isArray(itemModels)) {
+        return itemModels;
+    }
+    // Handle primitive list item types
+    // For primitive list items, the list will hold the primitive values as is,
+    // therefore, use JavaScript's `typeof` to infer the type of the values
+    const type = _.get(listItem, '_type');
+    if (!type) {
+        const type = typeof listItem;
+        if (typeIsPrimitive(type)) {
+            return { type: type };
+        }
+        return null;
+    }
+    if (type === 'reference') {
+        return _.find(itemModels, { type: 'reference' }) ?? null;
+    } else if (type === 'block') {
+        return _.find(itemModels, { type: 'richText' }) ?? null;
+    } else {
+        return (
+            _.find(itemModels, (itemModel) => {
+                if (itemModel.type === 'model') {
+                    return _.includes(itemModel.models, type);
+                } else {
+                    // if field was one of base types (object, image, slug, etc.)
+                    // and it had a "name" property, then the "_type" will be equal to that name,
+                    // otherwise the "_type" will be equal to the base type
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    return itemModel.name === type || itemModel.type === type;
+                }
+            }) ?? null
+        );
+    }
+}
+
+export function typeIsPrimitive(type: string): type is 'string' | 'number' | 'boolean' {
+    return ['string', 'number', 'boolean'].includes(type);
+}