@takeshape/schema 9.80.4 → 9.81.0

package/dist/versions.js

@@ -11,9 +11,7 @@ Object.defineProperty(exports, "CURRENT_SCHEMA_VERSION", {
   }
 });
 exports.LEGACY_SCHEMA_VERSION = exports.LEGACY_API_VERSION = void 0;
-
 var _schemas = require("./schemas");
-
 const LEGACY_SCHEMA_VERSION = '1.0.0';
 exports.LEGACY_SCHEMA_VERSION = LEGACY_SCHEMA_VERSION;
 const CURRENT_API_VERSION = '2';

package/dist/workflows.js

@@ -11,9 +11,7 @@ exports.getStepRange = getStepRange;
 exports.getWorkflow = getWorkflow;
 exports.getWorkflowStepKeys = getWorkflowStepKeys;
 exports.statusFallback = statusFallback;
-
 var _schemaUtil = require("./schema-util");
-
 const defaultWorkflow = {
   name: 'default',
   title: 'Default',
@@ -32,23 +30,17 @@ const defaultWorkflow = {
   }]
 };
 exports.defaultWorkflow = defaultWorkflow;
-
 function getWorkflow(projectSchema, shapeId) {
   var _getShapeById;
-
   const workflow = (_getShapeById = (0, _schemaUtil.getShapeById)(projectSchema, shapeId)) === null || _getShapeById === void 0 ? void 0 : _getShapeById.workflow;
-
   if (workflow) {
     return projectSchema.workflows[workflow] ?? defaultWorkflow;
   }
-
   return defaultWorkflow;
 }
-
 function statusFallback(workflow, enabled) {
   return workflow.steps.find(workflow => workflow.live === enabled) ?? workflow.steps[0];
 }
-
 function findWorkflowStep(workflow, keyOrName) {
   const index = workflow.steps.findIndex(workflow => workflow.key === keyOrName || workflow.name === keyOrName);
   return index === -1 ? undefined : {
@@ -56,7 +48,6 @@ function findWorkflowStep(workflow, keyOrName) {
     step: workflow.steps[index]
   };
 }
-
 function getStatusField(workflows, shape) {
   const workflow = shape.workflow && workflows[shape.workflow] || defaultWorkflow;
   return {
@@ -65,31 +56,25 @@ function getStatusField(workflows, shape) {
     '@workflow': workflow.name
   };
 }
-
 function getStepRange(steps, index, op) {
   if (op === 'eq' || op === 'in') {
     return [steps[index]];
   }
-
   const offset = op === 'lte' || op === 'gte' ? 0 : 1;
   const start = op === 'gt' || op === 'gte' ? index + offset : 0;
   const end = op === 'lt' || op === 'lte' ? index + 1 - offset : steps.length;
   return steps.slice(start, end);
 }
-
 function getWorkflowStepKeys(workflow, stepKey, op) {
   const context = findWorkflowStep(workflow, stepKey);
-
   if (!context) {
     throw new Error(`Cannot find step "${stepKey}" in workflow "${workflow.title}"`);
   }
-
   const {
     index
   } = context;
   return getStepRange(workflow.steps, index, op).map(step => step.key);
 }
-
 function getLiveStepKeys(workflow) {
   return workflow.steps.filter(step => step.live).map(step => step.key);
 }

package/es/api-version.js

@@ -2,18 +2,14 @@ import gte from 'semver/functions/gte';
 import coerce from 'semver/functions/coerce';
 export const createVersionPredicate = (featureVersion, comparison) => {
   const coercedFeatureVersion = coerce(featureVersion);
-
   if (!coercedFeatureVersion) {
     throw new Error(`Could not create predicate version "${featureVersion}" is not valid`);
   }
-
   return apiVersion => {
     const coercedApiVersion = coerce(apiVersion);
-
     if (!coercedApiVersion) {
       throw new Error(`Version "${apiVersion}" is not valid and could not be coerced`);
     }
-
     return comparison(coercedApiVersion, coercedFeatureVersion);
   };
 };

package/es/content-schema-transform.js

@@ -8,34 +8,28 @@ import { enumerateOneOfKeys, isUnionSchema } from './unions';
 const typeCache = new WeakMap();
 export function getType(schema) {
   let type = typeCache.get(schema);
-
   if (type) {
     return type;
   }
+  type = schema.type;
 
-  type = schema.type; // Handle nullable types for example: ['object', 'null']
-
+  // Handle nullable types for example: ['object', 'null']
   if (Array.isArray(type)) {
     const filtered = type.filter(name => name !== 'null');
-
     if (!filtered.length) {
       throw new Error(`Invalid schema`);
     }
-
     type = filtered[0];
   }
-
   typeCache.set(schema, type);
   return type;
 }
 export function toName(name) {
   return name;
 }
-
 function ensureArray(value) {
   return Array.isArray(value) ? value : [value];
 }
-
 export function preferKey(name, schema) {
   return getStorageKey(schema) ?? name;
 }
@@ -45,12 +39,10 @@ export function preferSourceKey(name, schema) {
 }
 export function findTransforms(pluginMap, schema, name, shape) {
   const type = getType(schema);
-
   if (pluginMap && (pluginMap[type] || pluginMap['*'])) {
     const plugins = (pluginMap[type] ?? []).concat(pluginMap['*'] ?? []);
     return plugins.find(plugin => plugin.filter(schema, name, shape));
   }
-
   return undefined;
 }
 export function getContentTransform({
@@ -65,22 +57,17 @@ export function getContentTransform({
   const prepare = (schema, obj, name = '') => {
     const shapeName = getRefShapeName(projectSchema, schema);
     schema = dereferenceSchema(projectSchema, schema);
-
     if (accumulators) {
       accumulators.forEach(accumulator => {
         accumulator.accumulate(obj, schema, name);
       });
     }
-
     const shape = shapeName ? projectSchema.shapes[shapeName] : undefined;
     const transform = findTransforms(transforms, schema, name, shape);
-
     if (transform) {
       const next = (value, schema, name) => prepare(schema, value, name);
-
       return transform.process(obj, schema, name, shape, next);
     }
-
     if (obj && isUnionSchema(schema)) {
       for (const {
         shapeId,
@@ -91,16 +78,13 @@ export function getContentTransform({
         }
       }
     }
-
     if (obj && isObjectSchema(schema)) {
       const result = {};
       const assigned = new Set();
       forEach(schema.properties, (fieldSchema, name) => {
         const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema, obj));
-
         for (const sourceKey of sourceKeys) {
           const value = prepare(fieldSchema, obj === null || obj === void 0 ? void 0 : obj[sourceKey], name);
-
           if (value !== undefined) {
             assigned.add(sourceKey);
             const transform = findTransforms(transforms, dereferenceSchema(projectSchema, fieldSchema), name);
@@ -109,51 +93,39 @@ export function getContentTransform({
           }
         }
       });
-
       if (passThrough && obj) {
         const keys = difference(Object.keys(obj), [...assigned]);
-
         if (keys.length) {
           Object.assign(result, pick(obj, keys));
         }
       }
-
       return result;
     }
-
     if (isArraySchema(schema)) {
       const itemSchema = schema.items;
-
       if (Array.isArray(obj)) {
         return obj.map(item => prepare(itemSchema, item, name));
       }
-
       if (obj === undefined) {
         prepare(itemSchema, obj, name);
       }
     }
-
     if (allowNullObjects && isObjectSchema(schema) && obj === null) {
       return null;
-    } // Allow properties that have not been transformed
-
+    }
 
+    // Allow properties that have not been transformed
     return passThrough ? obj : undefined;
   };
-
   return prepare;
 }
-
 function transformKey(transforms, propSchema, name, transform = preferKey) {
   const schemaTransform = findTransforms(transforms, propSchema, name);
-
   if (schemaTransform !== null && schemaTransform !== void 0 && schemaTransform.keyTransform) {
     transform = schemaTransform.keyTransform;
   }
-
   return transform(name, propSchema);
 }
-
 export function getPropertyInfo(context, schema, path) {
   const {
     projectSchema,
@@ -161,21 +133,16 @@ export function getPropertyInfo(context, schema, path) {
     keyTransform
   } = context;
   const result = [];
-
   const findProperty = (currentSchema, name, rest, path) => {
     if (isObjectSchema(currentSchema)) {
       var _currentSchema$requir;
-
       const propSchema = currentSchema.properties[name];
       const isRequired = ((_currentSchema$requir = currentSchema.required) === null || _currentSchema$requir === void 0 ? void 0 : _currentSchema$requir.includes(name)) ?? false;
-
       if (!propSchema) {
         return;
       }
-
       const refSchema = dereferenceSchema(projectSchema, propSchema);
       const nextPath = path.concat(transformKey(transforms, refSchema, name, keyTransform));
-
       if (rest.length) {
         const [nextName, ...nextRest] = rest;
         findProperty(refSchema, nextName, nextRest, nextPath);
@@ -194,7 +161,6 @@ export function getPropertyInfo(context, schema, path) {
       findProperty(dereferenceSchema(projectSchema, currentSchema.items), name, rest, path);
     }
   };
-
   const [first, ...rest] = path.split('.');
   findProperty(dereferenceSchema(projectSchema, schema), first, rest, []);
   return result;

package/es/create-input-schema.js

@@ -2,53 +2,46 @@ import defaults from 'lodash/fp/defaults';
 import { isRecord } from '@takeshape/util';
 import omitBy from 'lodash/omitBy';
 const inputSchemaCache = new Map();
-
 function getInputSchemaCache(options) {
   // Ensure key order does not invalidate the cache
   const key = JSON.stringify(options, Object.keys(options).sort());
   let cache = inputSchemaCache.get(key);
-
   if (!cache) {
     cache = new WeakMap();
     inputSchemaCache.set(key, cache);
   }
-
   return cache;
 }
+
 /**
  * Convert all output properties in the schema to be input properties,
  * For an update, remove `required` and `default` fields as well.
  */
-
-
 export function createInputSchema(schema, options = {}) {
   const inputSchemaCache = getInputSchemaCache(defaults({
     isUpdate: false
   }, options));
   let rewrittenSchema = inputSchemaCache.get(schema);
-
   if (rewrittenSchema) {
     return rewrittenSchema;
   }
-
   rewrittenSchema = JSON.parse(JSON.stringify(schema), (_key, value) => {
     if (isRecord(value)) {
       // Remove required
       if (options.isUpdate && Array.isArray(value.required) && value.required.length) {
         delete value.required;
-      } // Remove default
-
+      }
 
+      // Remove default
       if (options.isUpdate && value.type !== undefined && value.default !== undefined) {
         delete value.default;
       }
-
       if (value.type === 'object' && isRecord(value.properties)) {
-        return { ...value,
+        return {
+          ...value,
           properties: omitBy(value.properties, prop => isRecord(prop) && prop['@resolver'] && !prop['@input'])
         };
       }
-
       if (isRecord(value['@input'])) {
         const {
           '@input': input,
@@ -58,7 +51,8 @@ export function createInputSchema(schema, options = {}) {
           title,
           ...output
         } = value;
-        return { ...input,
+        return {
+          ...input,
           title,
           '@l10n': l10n,
           '@syncLocaleStructure': syncLocaleStructure,
@@ -67,7 +61,6 @@ export function createInputSchema(schema, options = {}) {
         };
       }
     }
-
     return value;
   });
   inputSchemaCache.set(schema, rewrittenSchema);

package/es/enum.js

@@ -2,10 +2,8 @@ export function isEnumLikeSchema(schema) {
   if (schema.enum) {
     return true;
   }
-
   if (schema.oneOf) {
     return schema.oneOf.every(optionSchema => optionSchema.title !== undefined && (optionSchema.enum || optionSchema.const));
   }
-
   return false;
 }

package/es/flatten-templates.js

@@ -5,13 +5,10 @@ import { deepClone } from '@takeshape/util';
 import { refItemToShapeName } from './refs';
 export function flattenTemplates(projectSchema) {
   const templateRefs = getAllRefs(projectSchema, ref => Boolean(ref.template));
-
   if (!templateRefs.length) {
     return projectSchema;
   }
-
   const newSchema = deepClone(projectSchema);
-
   for (const ref of templateRefs) {
     if (ref.template && isValidTemplate(ref.template)) {
       const {
@@ -22,6 +19,5 @@ export function flattenTemplates(projectSchema) {
       Object.assign(newSchema.shapes, dependencies);
     }
   }
-
   return newSchema;
 }

package/es/get-is-leaf.js

@@ -3,40 +3,36 @@ import { getStorageKey, isBuiltinType } from './schema-util';
 import { followRef, getRefShapeName } from './refs';
 import { isPropertySchemaWithRelationship } from './types';
 const scalarTags = new Set(['draftjs']);
-
 function isLeafTypeV3(projectSchema, propertySchema) {
   const type = getType(propertySchema);
-  return Boolean( // Must have key
-  getStorageKey(propertySchema) && ( // If is not a structure, then is a leaf
-  !['object', 'array'].includes(type) || // If is relationship, then is a leaf
-  isPropertySchemaWithRelationship(propertySchema['@output'] ?? propertySchema) || propertySchema['@tag'] && scalarTags.has(propertySchema['@tag']) || // If is array, then should not be a synchronized structure
+  return Boolean(
+  // Must have key
+  getStorageKey(propertySchema) && (
+  // If is not a structure, then is a leaf
+  !['object', 'array'].includes(type) ||
+  // If is relationship, then is a leaf
+  isPropertySchemaWithRelationship(propertySchema['@output'] ?? propertySchema) || propertySchema['@tag'] && scalarTags.has(propertySchema['@tag']) ||
+  // If is array, then should not be a synchronized structure
   type === 'array' && !propertySchema['@syncLocaleStructure'] || isBuiltinType(projectSchema, propertySchema)));
 }
-
 export function getIsLeaf(projectSchema, shapeSchema) {
   const leafMap = new Set();
   const shapesSeen = new Set();
-
   const collectLeaves = schema => {
     const shapeName = getRefShapeName(projectSchema, schema);
     schema = shapeName ? followRef(projectSchema, schema) : schema;
     const key = getStorageKey(schema);
-
     if (key && isLeafTypeV3(projectSchema, schema)) {
       leafMap.add(key);
     }
-
     if (shapeName) {
       // Skip shapes we have already seen to avoid cycles
       if (shapesSeen.has(shapeName)) {
         return;
       }
-
       shapesSeen.add(shapeName);
     }
-
     const combo = schema.oneOf ?? schema.allOf;
-
     if (combo) {
       combo.map(collectLeaves);
     } else if (schema.properties) {
@@ -47,7 +43,6 @@ export function getIsLeaf(projectSchema, shapeSchema) {
       collectLeaves(schema.items);
     }
   };
-
   collectLeaves(shapeSchema);
   return key => {
     // Remove locale suffix

package/es/index.js

@@ -1,4 +1,5 @@
 // Only export User here since AccessPolicyDocument is in auth-schemas
+
 export * from './content-schema-transform';
 export * from './get-is-leaf';
 export * from './project-schema';

package/es/interfaces.js

@@ -9,7 +9,6 @@ export function isInterfaceRef(context, propertySchema) {
   const ref = getRef(context, propertySchema);
   return Boolean(ref && isInterfaceShape(refItemToShape(context, ref)));
 }
-
 function add(record, key, value) {
   if (!record[key]) {
     record[key] = new Set([value]);
@@ -17,19 +16,15 @@ function add(record, key, value) {
     record[key].add(value);
   }
 }
-
 function getImplementationsHelper(shapeMap, mapFn) {
   const result = {};
-
   for (const shape of Object.values(shapeMap)) {
     for (const interfaceName of shape.interfaces ?? []) {
       add(result, interfaceName, mapFn(shape));
     }
   }
-
   return result;
 }
-
 export function getImplementationShapeMap(shapeMap) {
   return getImplementationsHelper(shapeMap, x => x);
 }
@@ -41,31 +36,26 @@ export function pruneUnusedInterfaces(shapeMap) {
     const {
       interfaces
     } = shape;
-
     if (interfaces !== null && interfaces !== void 0 && interfaces.length) {
       const filteredInterfaces = interfaces.filter(name => shapeMap[name]);
-
       if (interfaces.length !== filteredInterfaces.length) {
-        return { ...shape,
+        return {
+          ...shape,
           interfaces: filteredInterfaces
         };
       }
     }
-
     return shape;
   });
 }
 export function getImplementingShapes(shapeMap, interfaceName) {
   const implementingShapes = [];
-
   for (const shape of Object.values(shapeMap)) {
     var _shape$interfaces;
-
     if ((_shape$interfaces = shape.interfaces) !== null && _shape$interfaces !== void 0 && _shape$interfaces.includes(interfaceName)) {
       implementingShapes.push(shape);
     }
   }
-
   return implementingShapes;
 }
 export function interfaceToUnion(context, interfaceName) {
@@ -78,7 +68,6 @@ export function interfaceToUnion(context, interfaceName) {
 }
 export function getPossibleShapeNames(projectSchema, shape) {
   let names;
-
   if (isInterfaceShape(shape)) {
     names = getImplementingShapes(projectSchema.shapes, shape.name).map(shape => shape.name);
   } else if (isUnionSchema(shape.schema)) {
@@ -89,6 +78,5 @@ export function getPossibleShapeNames(projectSchema, shape) {
   } else {
     names = [shape.name];
   }
-
   return names;
 }