@takeshape/schema 7.194.0

package/lib/content-schema-transform.js

@@ -0,0 +1,217 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getType = getType;
+exports.toName = toName;
+exports.preferKey = preferKey;
+exports.findTransforms = findTransforms;
+exports.getContentTransform = getContentTransform;
+exports.getPropertyInfo = getPropertyInfo;
+
+var _forEach = _interopRequireDefault(require("lodash/forEach"));
+
+var _difference = _interopRequireDefault(require("lodash/difference"));
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _schemaUtil = require("./schema-util");
+
+var _types = require("./types");
+
+var _refs = require("./refs");
+
+var _unions = require("./unions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const typeCache = new WeakMap();
+
+function getType(schema) {
+  let type = typeCache.get(schema);
+
+  if (type) {
+    return type;
+  }
+
+  type = schema.type; // 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;
+}
+
+function toName(name) {
+  return name;
+}
+
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+function preferKey(name, schema) {
+  var _getKey;
+
+  return (_getKey = (0, _schemaUtil.getKey)(schema)) !== null && _getKey !== void 0 ? _getKey : name;
+}
+
+function findTransforms(pluginMap, schema, name, shape) {
+  const type = getType(schema);
+
+  if (pluginMap && (pluginMap[type] || pluginMap['*'])) {
+    var _pluginMap$type, _pluginMap$;
+
+    const plugins = ((_pluginMap$type = pluginMap[type]) !== null && _pluginMap$type !== void 0 ? _pluginMap$type : []).concat((_pluginMap$ = pluginMap['*']) !== null && _pluginMap$ !== void 0 ? _pluginMap$ : []);
+    return plugins.find(plugin => plugin.filter(schema, name, shape));
+  }
+
+  return undefined;
+}
+
+function getContentTransform({
+  transforms,
+  accumulators,
+  keyTransform = preferKey,
+  sourceKeyTransform = preferKey,
+  passThrough = true,
+  projectSchema
+}) {
+  const prepare = (schema, obj, name = '') => {
+    const shapeName = (0, _refs.getRefShapeName)(projectSchema, schema);
+    schema = (0, _schemaUtil.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 && (0, _unions.isUnionSchema)(schema)) {
+      for (const {
+        shapeId,
+        propSchema
+      } of (0, _unions.enumerateOneOfKeys)(projectSchema, schema.oneOf)) {
+        if (obj._shapeId === shapeId) {
+          return prepare(propSchema, obj, name);
+        }
+      }
+    }
+
+    if (obj && (0, _types.isObjectSchema)(schema)) {
+      const result = {};
+      const assigned = new Set();
+      (0, _forEach.default)(schema.properties, (fieldSchema, name) => {
+        const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema));
+
+        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, (0, _schemaUtil.dereferenceSchema)(projectSchema, fieldSchema), name);
+            const getKey = transform !== null && transform !== void 0 && transform.keyTransform ? transform.keyTransform : keyTransform;
+            result[getKey(name, fieldSchema, sourceKey)] = value;
+          }
+        }
+      });
+
+      if (passThrough && obj) {
+        const keys = (0, _difference.default)(Object.keys(obj), [...assigned]);
+
+        if (keys.length) {
+          Object.assign(result, (0, _pick.default)(obj, keys));
+        }
+      }
+
+      return result;
+    }
+
+    if ((0, _types.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);
+      }
+    } // 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);
+}
+
+function getPropertyInfo(context, schema, path) {
+  const {
+    projectSchema,
+    transforms,
+    keyTransform
+  } = context;
+  const result = [];
+
+  const findProperty = (currentSchema, name, rest, path) => {
+    if ((0, _types.isObjectSchema)(currentSchema)) {
+      const propSchema = currentSchema.properties[name];
+
+      if (!propSchema) {
+        return;
+      }
+
+      const refSchema = (0, _schemaUtil.dereferenceSchema)(projectSchema, propSchema);
+      const nextPath = path.concat(transformKey(transforms, refSchema, name, keyTransform));
+
+      if (rest.length) {
+        const [nextName, ...nextRest] = rest;
+        findProperty(refSchema, nextName, nextRest, nextPath);
+      } else {
+        result.push({
+          schema: refSchema,
+          key: nextPath.join('.')
+        });
+      }
+    } else if ((0, _unions.isUnionSchema)(currentSchema)) {
+      for (const optionSchema of currentSchema.oneOf) {
+        findProperty((0, _schemaUtil.dereferenceSchema)(projectSchema, optionSchema), name, rest, path);
+      }
+    } else if ((0, _types.isArraySchema)(currentSchema)) {
+      findProperty((0, _schemaUtil.dereferenceSchema)(projectSchema, currentSchema.items), name, rest, path);
+    }
+  };
+
+  const [first, ...rest] = path.split('.');
+  findProperty((0, _schemaUtil.dereferenceSchema)(projectSchema, schema), first, rest, []);
+  return result;
+}

package/lib/entitlements.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=entitlements.d.ts.map

package/lib/entitlements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entitlements.d.ts","sourceRoot":"","sources":["../../src/entitlements.ts"],"names":[],"mappings":""}

package/lib/entitlements.js

@@ -0,0 +1 @@
+"use strict";

package/lib/enum.d.ts

@@ -0,0 +1,3 @@
+import { ContentSchema } from './project-schema';
+export declare function isEnumSchema(schema: ContentSchema): boolean;
+//# sourceMappingURL=enum.d.ts.map

package/lib/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAE/C,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAW3D"}

package/lib/enum.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEnumSchema = isEnumSchema;
+
+function isEnumSchema(schema) {
+  if (schema.enum) {
+    return true;
+  }
+
+  if (schema.oneOf) {
+    return schema.oneOf.every(optionSchema => optionSchema.title !== undefined && (optionSchema.enum || optionSchema.const));
+  }
+
+  return false;
+}

package/lib/get-is-leaf.d.ts

@@ -0,0 +1,4 @@
+import { ProjectSchema, ContentSchema } from './project-schema';
+export declare type IsLeaf = (key?: string) => boolean;
+export declare function getIsLeaf(projectSchema: ProjectSchema, shapeSchema: ContentSchema): IsLeaf;
+//# sourceMappingURL=get-is-leaf.d.ts.map

package/lib/get-is-leaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-is-leaf.d.ts","sourceRoot":"","sources":["../../src/get-is-leaf.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAsB9D,oBAAY,MAAM,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;AAE/C,wBAAgB,SAAS,CAAC,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,GAAG,MAAM,CAsC1F"}

package/lib/get-is-leaf.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIsLeaf = getIsLeaf;
+
+var _contentSchemaTransform = require("./content-schema-transform");
+
+var _schemaUtil = require("./schema-util");
+
+var _refs = require("./refs");
+
+const scalarTags = new Set(['draftjs']);
+
+function isLeafTypeV3(projectSchema, contentSchema) {
+  const type = (0, _contentSchemaTransform.getType)(contentSchema);
+  return Boolean( // must have key
+  (0, _schemaUtil.getKey)(contentSchema) && ( // if is not a structure, then is a leaf
+  !['object', 'array'].includes(type) || // if is relationship, then is a leaf
+  contentSchema['@relationship'] || contentSchema['@tag'] && scalarTags.has(contentSchema['@tag']) || // if is array, then should not be a synchronized structure
+  type === 'array' && !contentSchema['@syncLocaleStructure'] || (0, _schemaUtil.isBuiltinType)(projectSchema, contentSchema)));
+}
+
+function getIsLeaf(projectSchema, shapeSchema) {
+  const leafMap = new Set();
+  const shapesSeen = new Set();
+
+  const collectLeaves = schema => {
+    var _schema$oneOf;
+
+    const shapeName = (0, _refs.getRefShapeName)(projectSchema, schema);
+    schema = shapeName ? (0, _refs.followRef)(projectSchema, schema) : schema;
+    const key = (0, _schemaUtil.getKey)(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.oneOf) !== null && _schema$oneOf !== void 0 ? _schema$oneOf : schema.allOf;
+
+    if (combo) {
+      combo.map(collectLeaves);
+    } else if (schema.properties) {
+      for (const name of Object.keys(schema.properties)) {
+        collectLeaves(schema.properties[name]);
+      }
+    } else if (schema.items) {
+      collectLeaves(schema.items);
+    }
+  };
+
+  collectLeaves(shapeSchema);
+  return key => {
+    // remove locale suffix
+    key = key ? key.split(':')[0] : key;
+    return Boolean(key && leafMap.has(key));
+  };
+}

package/lib/index.d.ts

@@ -0,0 +1,27 @@
+export type { ProjectSchemaUpdate, ProjectSchemaMigrationContext } from './migration';
+export * from './content-schema-transform';
+export * from './get-is-leaf';
+export * from './project-schema';
+export * from './schema-util';
+export * from './services';
+export * from './template-shapes';
+export * from './taxonomies';
+export * from './types';
+export * from './workflows';
+export * from './builtin-schema';
+export * from './auth-schemas';
+export type { User } from './user-schema';
+export * from './api-version';
+export { listTypePrefix, ensureLatest, normalizeSchemaVersion, getRelationshipSchema, migrateToLatestProjectSchema } from './migration';
+export * from './validate';
+export { builtInShapes } from './builtin-schema';
+export * from './versions';
+export * from './mocks';
+export * from './util';
+export * from './resolvers';
+export * from './scalars';
+export * from './refs';
+export * from './unions';
+export * from './enum';
+export * from './patterns';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,mBAAmB,EAAE,6BAA6B,EAAC,MAAM,aAAa,CAAC;AACpF,cAAc,4BAA4B,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAE/B,YAAY,EAAC,IAAI,EAAC,MAAM,eAAe,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,aAAa,CAAC;AACrB,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAC/C,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}