@takeshape/schema 11.144.1 → 11.154.1

package/dist/content-schema-transform.d.ts

@@ -1,35 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, ShapeJSON } from './project-schema/index.ts';
-import type { ContentTransform, KeyTransform, PropertyTransform, PropertyTransformMap, SchemaType, SourceKeyTransform } from './types/index.ts';
-export declare function getType(schema: Pick<PropertySchema, 'type'>): SchemaType;
-export declare function preferKey(name: string, schema: PropertySchema): string;
-/**
- * A key transform to select the field name
- */
-export declare const preferName: KeyTransform;
-export declare function preferSourceKey(name: string, schema: PropertySchema): string[];
-export declare function findTransforms(pluginMap: PropertyTransformMap | undefined, schema: PropertySchema, name: string, shape?: ShapeJSON): PropertyTransform | undefined;
-export type Accumulator<T = unknown> = {
-    accumulate(value: unknown, schema: PropertySchema, name: string): void;
-    getResults(): T;
-};
-export type ContentTransformParams = {
-    transforms?: PropertyTransformMap;
-    accumulators?: Accumulator[];
-    projectSchema: ProjectSchemaJSON;
-    keyTransform?: KeyTransform;
-    sourceKeyTransform?: SourceKeyTransform;
-    passThrough?: boolean;
-    allowNullObjects?: boolean;
-};
-export declare function getContentTransform({ transforms, accumulators, keyTransform, sourceKeyTransform, passThrough, allowNullObjects, projectSchema }: ContentTransformParams): ContentTransform;
-export type PropertyInfo = {
-    schema: PropertySchema;
-    key: string;
-    isRequired: boolean;
-};
-export type GetPropertyInfoContext = {
-    projectSchema: ProjectSchemaJSON;
-    transforms?: PropertyTransformMap;
-    keyTransform?: KeyTransform;
-};
-export declare function getPropertyInfo(context: GetPropertyInfoContext, schema: PropertySchema, path: string): PropertyInfo[];

package/dist/content-schema-transform.js

@@ -1,162 +0,0 @@
-import difference from 'lodash/difference.js';
-import forEach from 'lodash/forEach.js';
-import get from 'lodash/get.js';
-import pick from 'lodash/pick.js';
-import { dereferenceSchema, getRefShapeName } from "./refs.js";
-import { getStorageKey } from "./schema-util.js";
-import { isArraySchema, isObjectSchema } from "./types/utils.js";
-import { enumerateOneOfKeys, isUnionSchema } from "./unions.js";
-const typeCache = new WeakMap();
-export 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 ensureArray(value) {
-    return Array.isArray(value) ? value : [value];
-}
-export function preferKey(name, schema) {
-    return getStorageKey(schema) ?? name;
-}
-/**
- * A key transform to select the field name
- */
-export const preferName = (name) => name;
-function getLocalizedKey(key, locale) {
-    return locale ? `${key}:${locale}` : key;
-}
-function getNonDefaultLocales(projectSchema) {
-    return projectSchema.locales.filter((locale) => locale !== projectSchema.defaultLocale);
-}
-function getLocalizedSourceKeys(keys, locales) {
-    return keys.flatMap((key) => [{ key }, ...locales.map((locale) => ({ key: `${key}:${locale}`, locale }))]);
-}
-export function preferSourceKey(name, schema) {
-    const key = getStorageKey(schema);
-    return key ? [key, name] : [name];
-}
-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({ transforms, accumulators, keyTransform = preferKey, sourceKeyTransform = preferSourceKey, passThrough = true, allowNullObjects = false, projectSchema }) {
-    const nonDefaultLocales = getNonDefaultLocales(projectSchema);
-    const prepare = (schema, obj, name = '', parent) => {
-        const shapeName = getRefShapeName(projectSchema, schema);
-        schema = dereferenceSchema(projectSchema, schema);
-        if (accumulators) {
-            for (const accumulator of accumulators) {
-                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, parent) => prepare(schema, value, name, parent);
-            return transform.process(obj, { ...schema, $parent: parent }, name, shape, next);
-        }
-        if (obj && isUnionSchema(schema)) {
-            for (const { shapeId, propSchema } of enumerateOneOfKeys(projectSchema, schema.oneOf)) {
-                if (obj._shapeId === shapeId) {
-                    return prepare(propSchema, obj, name, schema);
-                }
-            }
-        }
-        if (obj && isObjectSchema(schema)) {
-            const result = {};
-            const assigned = new Set();
-            forEach(schema.properties, (fieldSchema, name) => {
-                const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema, obj));
-                const localizedSourceKeys = getLocalizedSourceKeys(sourceKeys, nonDefaultLocales);
-                for (const { key: sourceKey, locale } of localizedSourceKeys) {
-                    const value = prepare(fieldSchema, get(obj, sourceKey), name, schema);
-                    if (value !== undefined) {
-                        assigned.add(sourceKey);
-                        const transform = findTransforms(transforms, dereferenceSchema(projectSchema, fieldSchema), name);
-                        const getKey = transform?.keyTransform ? transform.keyTransform : keyTransform;
-                        const key = getLocalizedKey(getKey(name, fieldSchema, sourceKey), locale);
-                        result[key] = value;
-                    }
-                }
-            });
-            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, schema));
-            }
-            if (obj === undefined) {
-                prepare(itemSchema, obj, name, parent);
-            }
-        }
-        if (allowNullObjects && isObjectSchema(schema) && obj === null) {
-            return null;
-        }
-        // 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?.keyTransform) {
-        transform = schemaTransform.keyTransform;
-    }
-    return transform(name, propSchema);
-}
-export function getPropertyInfo(context, schema, path) {
-    const { projectSchema, transforms, keyTransform } = context;
-    const result = [];
-    const findProperty = (currentSchema, name, rest, path) => {
-        if (isObjectSchema(currentSchema)) {
-            const propSchema = currentSchema.properties[name];
-            const isRequired = currentSchema.required?.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);
-            }
-            else {
-                result.push({ schema: refSchema, key: nextPath.join('.'), isRequired });
-            }
-        }
-        else if (isUnionSchema(currentSchema)) {
-            for (const optionSchema of currentSchema.oneOf) {
-                findProperty(dereferenceSchema(projectSchema, optionSchema), name, rest, path);
-            }
-        }
-        else if (isArraySchema(currentSchema)) {
-            findProperty(dereferenceSchema(projectSchema, currentSchema.items), name, rest, path);
-        }
-    };
-    const [first, ...rest] = path.split('.');
-    findProperty(dereferenceSchema(projectSchema, schema), first, rest, []);
-    return result;
-}

package/dist/create-input-schema.d.ts

@@ -1,9 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, ShapeSchema } from './project-schema/index.ts';
-export type CreateInputSchemaOptions = {
-    isUpdate?: boolean;
-};
-/**
- * Convert all output properties in the schema to be input properties,
- * For an update, remove `required` and `default` fields as well.
- */
-export declare function createInputSchema<T extends ProjectSchemaJSON | ShapeSchema | PropertySchema>(schema: T, options?: CreateInputSchemaOptions): T;

package/dist/create-input-schema.js

@@ -1,68 +0,0 @@
-import { deepCloneWith, isIterableObject, REMOVE } from '@takeshape/util';
-import defaults from 'lodash/fp/defaults.js';
-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 = deepCloneWith(schema, (value, key, parent, clone) => {
-        // Remove required
-        if (options.isUpdate && key === 'required' && Array.isArray(value) && value.length) {
-            return REMOVE;
-        }
-        // Remove default
-        if (options.isUpdate &&
-            key === 'default' &&
-            value !== undefined &&
-            isIterableObject(parent) &&
-            parent.type !== undefined) {
-            return REMOVE;
-        }
-        if (isIterableObject(value) && value.type === 'object' && isIterableObject(value.properties)) {
-            const properties = {};
-            for (const [key, prop] of Object.entries(value.properties)) {
-                if (isIterableObject(prop) && (!prop['@resolver'] || prop['@input'])) {
-                    properties[key] = clone(prop, key, value);
-                }
-            }
-            let required;
-            if (!options.isUpdate && Array.isArray(value.required)) {
-                required = value.required.filter((key) => Boolean(properties[key]));
-            }
-            return {
-                ...value,
-                properties,
-                required
-            };
-        }
-        if (isIterableObject(value) && isIterableObject(value['@input'])) {
-            const { '@input': input, '@l10n': l10n, '@syncLocaleStructure': syncLocaleStructure, '@mapping': mapping, title, ...output } = value;
-            return {
-                ...clone(input, '@input', value),
-                title,
-                '@l10n': l10n,
-                '@syncLocaleStructure': syncLocaleStructure,
-                '@mapping': mapping,
-                '@output': output
-            };
-        }
-    });
-    inputSchemaCache.set(schema, rewrittenSchema);
-    return rewrittenSchema;
-}

package/dist/enum.d.ts

@@ -1,2 +0,0 @@
-import type { PropertySchema } from './project-schema/index.ts';
-export declare function isEnumLikeSchema(schema: PropertySchema): boolean;

package/dist/enum.js

@@ -1,9 +0,0 @@
-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/dist/flatten-templates.d.ts

@@ -1,2 +0,0 @@
-import type { ProjectSchemaJSON } from './project-schema/index.ts';
-export declare function flattenTemplates<T extends ProjectSchemaJSON>(projectSchema: T): T;

package/dist/flatten-templates.js

@@ -1,20 +0,0 @@
-import { deepClone } from '@takeshape/util';
-import set from 'lodash/set.js';
-import { refItemToNamespacedShapeName } from "./refs.js";
-import { getAllRefs } from "./schema-util.js";
-import { isValidTemplate, resolveTemplate } from "./template-shapes/index.js";
-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 { shapeName, dependencies } = resolveTemplate(newSchema, ref.template, refItemToNamespacedShapeName(newSchema, ref));
-            set(newSchema, ref.path, ref.path[ref.path.length - 1] === '@ref' ? `local:${shapeName}` : shapeName);
-            Object.assign(newSchema.shapes, dependencies);
-        }
-    }
-    return newSchema;
-}

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

@@ -1,3 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema } from './project-schema/index.ts';
-export type IsLeaf = (key?: string) => boolean;
-export declare function getIsLeaf(projectSchema: ProjectSchemaJSON, shapeSchema: PropertySchema): IsLeaf;

package/dist/get-is-leaf.js

@@ -1,56 +0,0 @@
-import { getType } from "./content-schema-transform.js";
-import { followRef, getRefShapeName } from "./refs.js";
-import { getStorageKey, isBuiltinType } from "./schema-util.js";
-import { isPropertySchemaWithRelationship } from "./types/index.js";
-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) ||
-            Boolean(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) {
-            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/dist/index.d.ts

@@ -1,62 +0,0 @@
-export * from './agents.ts';
-export * from './api-version.ts';
-export type { AccessPolicyDocument, ApiKey, Condition, Role, RoleImport, RoleInput, Statement, User, UserPermission } from './auth-schemas.ts';
-export * from './auth-utils.ts';
-export * from './builtin-schema.ts';
-export * from './constants.ts';
-export * from './content-schema-transform.ts';
-export * from './create-input-schema.ts';
-export * from './enum.ts';
-export * from './flatten-templates.ts';
-export * from './get-is-leaf.ts';
-export * from './interfaces.ts';
-export * from './migration/index.ts';
-export type { ProjectSchemaUpdate } from './migration/types.ts';
-export { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, MCP_TOOLS_UPDATE_KEY } from './migration/types.ts';
-export * from './mocks.ts';
-export * from './models/runtime-schema.ts';
-export * from './models/types.ts';
-export * from './models/user-schema.ts';
-export * from './patterns.ts';
-export * from './project-schema/index.ts';
-export * from './project-schema/migrate.ts';
-export * from './refs.ts';
-export * from './relationships.ts';
-export * from './resolvers/ai/agent-message-payload.ts';
-export type { AgentSessionPayload } from './resolvers/ai/agent-session-payload.ts';
-export * from './resolvers/takeshape/assets/constants.ts';
-export * from './runtime-schema.ts';
-export * from './scalars.ts';
-export * from './schema-transform.ts';
-export * from './schema-util.ts';
-export * from './service-dependencies.ts';
-export * from './services/services.ts';
-export * from './services/types.ts';
-export * from './services/util.ts';
-export * from './shape-paths.ts';
-export * from './taxonomies.ts';
-export * from './template-shapes/index.ts';
-export * from './types/transforms.ts';
-export * from './types/types.ts';
-export * from './types/utils.ts';
-export * from './unions.ts';
-export * from './util/ai-tools.ts';
-export * from './util/api-indexing.ts';
-export * from './util/coerce-value.ts';
-export * from './util/detect-cycles.ts';
-export * from './util/expressions.ts';
-export * from './util/find-shape-at-path.ts';
-export * from './util/form-config.ts';
-export * from './util/get-conflicting-properties.ts';
-export * from './util/get-return-shape.ts';
-export * from './util/has-arg.ts';
-export * from './util/is-asset-property.ts';
-export * from './util/mcp.ts';
-export * from './util/merge.ts';
-export * from './util/patch-schema.ts';
-export * from './util/query-field-path.ts';
-export * from './util/shapes.ts';
-export * from './validate/errors.ts';
-export * from './validate/validate.ts';
-export * from './versions.ts';
-export * from './workflows.ts';

package/dist/index.js

@@ -1,59 +0,0 @@
-export * from "./agents.js";
-export * from "./api-version.js";
-export * from "./auth-utils.js";
-export * from "./builtin-schema.js";
-export * from "./constants.js";
-export * from "./content-schema-transform.js";
-export * from "./create-input-schema.js";
-export * from "./enum.js";
-export * from "./flatten-templates.js";
-export * from "./get-is-leaf.js";
-export * from "./interfaces.js";
-export * from "./migration/index.js";
-export { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, MCP_TOOLS_UPDATE_KEY } from "./migration/types.js";
-export * from "./mocks.js";
-export * from "./models/runtime-schema.js";
-export * from "./models/types.js";
-export * from "./models/user-schema.js";
-export * from "./patterns.js";
-export * from "./project-schema/index.js";
-export * from "./project-schema/migrate.js";
-export * from "./refs.js";
-export * from "./relationships.js";
-export * from "./resolvers/ai/agent-message-payload.js";
-export * from "./resolvers/takeshape/assets/constants.js";
-export * from "./runtime-schema.js";
-export * from "./scalars.js";
-export * from "./schema-transform.js";
-export * from "./schema-util.js";
-export * from "./service-dependencies.js";
-export * from "./services/services.js";
-export * from "./services/types.js";
-export * from "./services/util.js";
-export * from "./shape-paths.js";
-export * from "./taxonomies.js";
-export * from "./template-shapes/index.js";
-export * from "./types/transforms.js";
-export * from "./types/types.js";
-export * from "./types/utils.js";
-export * from "./unions.js";
-export * from "./util/ai-tools.js";
-export * from "./util/api-indexing.js";
-export * from "./util/coerce-value.js";
-export * from "./util/detect-cycles.js";
-export * from "./util/expressions.js";
-export * from "./util/find-shape-at-path.js";
-export * from "./util/form-config.js";
-export * from "./util/get-conflicting-properties.js";
-export * from "./util/get-return-shape.js";
-export * from "./util/has-arg.js";
-export * from "./util/is-asset-property.js";
-export * from "./util/mcp.js";
-export * from "./util/merge.js";
-export * from "./util/patch-schema.js";
-export * from "./util/query-field-path.js";
-export * from "./util/shapes.js";
-export * from "./validate/errors.js";
-export * from "./validate/validate.js";
-export * from "./versions.js";
-export * from "./workflows.js";

package/dist/interfaces.d.ts

@@ -1,14 +0,0 @@
-import type { OneOfSchema, ProjectSchemaJSON, PropertySchema, ShapeJSON, ShapeMap } from './project-schema/index.ts';
-import { type RefItem, type ServicesShapesContext } from './refs.ts';
-export declare function isInterfaceShape(shape?: ShapeJSON): shape is ShapeJSON & {
-    type: 'interface';
-};
-export type ImplementationShapeMap = Record<string, Set<ShapeJSON>>;
-export type ImplementationShapeNameMap = Record<string, Set<string>>;
-export declare function isInterfaceRef(context: ServicesShapesContext, propertySchema: PropertySchema): boolean;
-export declare function getImplementationShapeMap(shapeMap: ShapeMap): ImplementationShapeMap;
-export declare function getImplementationShapeNameMap(shapeMap: ShapeMap): ImplementationShapeNameMap;
-export declare function pruneUnusedInterfaces(projectSchema: ProjectSchemaJSON, shapeMap: ShapeMap): ShapeMap;
-export declare function getImplementingShapes(context: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, interfaceRef: RefItem): ShapeJSON[];
-export declare function interfaceToUnion(context: Pick<ProjectSchemaJSON, 'shapes' | 'services'>, interfaceRef: RefItem): OneOfSchema;
-export declare function getPossibleShapeNames(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): string[];

package/dist/interfaces.js

@@ -1,86 +0,0 @@
-import { isDefined } from '@takeshape/util';
-import mapValues from 'lodash/mapValues.js';
-import { getRef, getShapeByRef, normalizeRefExpression, parseRef, refItemToNamespacedShapeName, refItemToShape, shapeToRefItem } from "./refs.js";
-import { isUnionSchema } from "./unions.js";
-export function isInterfaceShape(shape) {
-    return shape?.type === 'interface';
-}
-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]);
-    }
-    else {
-        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);
-}
-export function getImplementationShapeNameMap(shapeMap) {
-    return getImplementationsHelper(shapeMap, (shape) => shape.name);
-}
-export function pruneUnusedInterfaces(projectSchema, shapeMap) {
-    return mapValues(shapeMap, (shape) => {
-        const { interfaces } = shape;
-        if (interfaces?.length) {
-            const context = { ...projectSchema, shapes: shapeMap };
-            const filteredInterfaces = interfaces.filter((refExpression) => getShapeByRef(context, refExpression));
-            if (interfaces.length !== filteredInterfaces.length) {
-                return { ...shape, interfaces: filteredInterfaces };
-            }
-        }
-        return shape;
-    });
-}
-function compareRefItems(refItem1, refItem2) {
-    return refItem1.shapeName === refItem2.shapeName && refItem1.layerId === refItem2.layerId;
-}
-export function getImplementingShapes(context, interfaceRef) {
-    const shapeMap = context.shapes;
-    const implementingShapes = [];
-    for (const shape of Object.values(shapeMap)) {
-        if (shape.interfaces?.find((interfaceRefExpression) => compareRefItems(parseRef(context, interfaceRefExpression), interfaceRef))) {
-            implementingShapes.push(shape);
-        }
-    }
-    return implementingShapes;
-}
-export function interfaceToUnion(context, interfaceRef) {
-    const shapes = getImplementingShapes(context, interfaceRef);
-    return {
-        oneOf: shapes.map((shape) => ({
-            '@ref': normalizeRefExpression(context, shape.name)
-        }))
-    };
-}
-export function getPossibleShapeNames(projectSchema, shape) {
-    let names;
-    if (isInterfaceShape(shape)) {
-        names = getImplementingShapes(projectSchema, shapeToRefItem(projectSchema, shape)).map((shape) => shape.name);
-    }
-    else if (isUnionSchema(shape.schema)) {
-        names = shape.schema.oneOf
-            .map((member) => {
-            const ref = getRef(projectSchema, member);
-            return ref && refItemToNamespacedShapeName(projectSchema, ref);
-        })
-            .filter(isDefined);
-    }
-    else {
-        names = [shape.name];
-    }
-    return names;
-}

package/dist/layers/layers.d.ts

@@ -1,26 +0,0 @@
-import type { FlattenedSchemaV4_0_0, LayerSchemaV4_0_0, ObjectSchemaV4_0_0, ProjectSchemaJSONV4_0_0, PropertySchemaV4_0_0, QueryJSONV4_0_0, ShapeMapV4_0_0 } from '../project-schema/index.ts';
-import { type RefItemWithPath } from './refs.ts';
-export type GetLayer = (layerId: string) => LayerSchemaV4_0_0 | undefined;
-export declare function isObjectSchemaV4_0_0(maybeObjectSchema: PropertySchemaV4_0_0): maybeObjectSchema is ObjectSchemaV4_0_0;
-export type RefPredicate = (ref: RefItemWithPath) => boolean;
-/**
- * Walk through a `ProjectSchema` and collect all the `ref`s.
- */
-export declare function getAllRefsInShapes(shapes: ShapeMapV4_0_0, predicate?: RefPredicate): RefItemWithPath[];
-/**
- * Get all refs
- */
-export declare function getAllRefsInQuery(shapes: ShapeMapV4_0_0, queryPath: string[], query: QueryJSONV4_0_0, predicate?: (ref: RefItemWithPath) => boolean): RefItemWithPath[];
-type SchemaContext = Pick<FlattenedSchemaV4_0_0, 'shapes' | 'queries' | 'mutations'>;
-/**
- * Collect refs from `queries` or `mutations`.
- */
-export declare function getAllRefsInQueries(context: SchemaContext, rootPropertyName: 'queries' | 'mutations', predicate?: RefPredicate): RefItemWithPath[];
-/**
- * Get all refs in a ProjectSchema
- * @param predicate return true to include the ref in
- */
-export declare function getAllRefs(projectSchema: SchemaContext, predicate?: RefPredicate): RefItemWithPath[];
-export declare function collectReferencedShapeNames(layerId: string, refSet: Set<string>): (schema: PropertySchemaV4_0_0) => void;
-export declare function flattenSchema(projectSchema: ProjectSchemaJSONV4_0_0, getLayer: GetLayer): FlattenedSchemaV4_0_0;
-export {};