@fluidframework/tree 2.4.0-294316 → 2.4.0-297027

package/src/simple-tree/schemaTypes.ts

@@ -221,7 +221,7 @@ export interface FieldSchemaMetadata<TCustomMetadata = unknown> {
 	/**
 	 * User-defined metadata.
 	 */
-	custom?: TCustomMetadata;
+	readonly custom?: TCustomMetadata;
 
 	/**
 	 * The description of the field.
@@ -232,7 +232,7 @@ export interface FieldSchemaMetadata<TCustomMetadata = unknown> {
 	 * E.g., when converting a field schema to {@link https://json-schema.org/ | JSON Schema}, this description will be
 	 * used as the `description` field.
 	 */
-	description?: string | undefined;
+	readonly description?: string | undefined;
 }
 
 /**

package/src/simple-tree/toFlexSchema.ts

@@ -8,131 +8,73 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	EmptyKey,
+	LeafNodeStoredSchema,
+	MapNodeStoredSchema,
+	ObjectNodeStoredSchema,
+	type FieldKey,
+	type FieldKindIdentifier,
+	type TreeFieldStoredSchema,
 	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
+	type TreeTypeSet,
 } from "../core/index.js";
-import {
-	FieldKinds,
-	type FlexAllowedTypes,
-	type FlexFieldKind,
-	FlexFieldSchema,
-	FlexMapNodeSchema,
-	FlexObjectNodeSchema,
-	type FlexTreeNodeSchema,
-	type FlexTreeSchema,
-	TreeNodeSchemaBase,
-	defaultSchemaPolicy,
-	intoStoredSchemaCollection,
-	schemaIsLeaf,
-} from "../feature-libraries/index.js";
+import { FieldKinds, type FlexFieldKind } from "../feature-libraries/index.js";
 // TODO: once flex schema is gone, this code can move into simple-tree
 // eslint-disable-next-line import/no-internal-modules
 import { normalizeFlexListEager } from "../feature-libraries/typed-schema/index.js";
-import { brand, fail, isReadonlyArray, mapIterable } from "../util/index.js";
-import {
-	cachedFlexSchemaFromClassSchema,
-	setFlexSchemaFromClassSchema,
-	tryGetSimpleNodeSchema,
-	NodeKind,
-	type TreeNodeSchema,
-} from "./core/index.js";
+import { brand, fail, isReadonlyArray } from "../util/index.js";
+import { NodeKind, type TreeNodeSchema } from "./core/index.js";
 import {
 	FieldKind,
 	FieldSchema,
 	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
-	getStoredKey,
 } from "./schemaTypes.js";
-
-interface SchemaInfo {
-	readonly toFlex: () => FlexTreeNodeSchema;
-	readonly original: TreeNodeSchema;
-}
-
-type SchemaMap = Map<TreeNodeSchemaIdentifier, SchemaInfo>;
+import { walkFieldSchema } from "./walkFieldSchema.js";
+import { LeafNodeSchema } from "./leafNodeSchema.js";
+import { isObjectNodeSchema } from "./objectNodeTypes.js";
 
 /**
- * Generate a {@link FlexTreeSchema} with `root` as the root field.
- *
- * This also has the side effect of populating the cached view schema on the class-based schema.
+ * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
  */
-export function toFlexSchema(root: ImplicitFieldSchema): FlexTreeSchema {
-	const schemaMap: SchemaMap = new Map();
-	const field = convertField(schemaMap, root);
-	const nodeSchema = new Map(
-		mapIterable(schemaMap, ([key, value]) => {
-			const schema = value.toFlex();
-			const classSchema = tryGetSimpleNodeSchema(schema);
-			if (classSchema === undefined) {
-				assert(schemaIsLeaf(schema), 0x83e /* invalid leaf */);
-			} else {
-				assert(
-					cachedFlexSchemaFromClassSchema(classSchema) === schema,
-					0x83f /* mismatched schema */,
+export function toStoredSchema(root: ImplicitFieldSchema): TreeStoredSchema {
+	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
+	walkFieldSchema(root, {
+		node(schema) {
+			if (nodeSchema.has(brand(schema.identifier))) {
+				// Use JSON.stringify to quote and escape identifier string.
+				throw new UsageError(
+					`Multiple schema encountered with the identifier ${JSON.stringify(
+						schema.identifier,
+					)}. Remove or rename them to avoid the collision.`,
 				);
 			}
-			return [key, schema];
-		}),
-	);
+			nodeSchema.set(brand(schema.identifier), getStoredSchema(schema));
+		},
+	});
 
-	const typed: FlexTreeSchema = {
-		nodeSchema,
-		adapters: {},
-		rootFieldSchema: field,
-		policy: defaultSchemaPolicy,
-	};
-	return typed;
-}
-
-/**
- * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
- */
-export function toStoredSchema(root: ImplicitFieldSchema): TreeStoredSchema {
-	const flex = toFlexSchema(root);
 	return {
-		rootFieldSchema: flex.rootFieldSchema.stored,
-		...intoStoredSchemaCollection(flex),
+		nodeSchema,
+		rootFieldSchema: convertField(root),
 	};
 }
 
-/**
- * Return a flex schema for the provided class schema.
- *
- * This also has the side effect of populating the cached view schema on the class based schema.
- */
-export function getFlexSchema(root: TreeNodeSchema): FlexTreeNodeSchema {
-	const treeSchema = toFlexSchema(root);
-	return treeSchema.rootFieldSchema.monomorphicChildType ?? fail("root should be monomorphic");
-}
-
-/**
- * Return a stored schema for the provided class schema.
- *
- * This also has the side effect of populating the cached view schema on the class based schema.
- */
-export function getStoredSchema(root: TreeNodeSchema): TreeNodeStoredSchema {
-	return getFlexSchema(root).stored;
-}
-
 /**
  * Normalizes an {@link ImplicitFieldSchema} into a {@link TreeFieldSchema}.
  */
-export function convertField(
-	schemaMap: SchemaMap,
-	schema: ImplicitFieldSchema,
-): FlexFieldSchema {
-	let kind: FlexFieldKind;
-	let types: ImplicitAllowedTypes;
+export function convertField(schema: ImplicitFieldSchema): TreeFieldStoredSchema {
+	let kind: FieldKindIdentifier;
+	let allowedTypes: ImplicitAllowedTypes;
 	if (schema instanceof FieldSchema) {
-		kind = convertFieldKind.get(schema.kind) ?? fail("Invalid field kind");
-		types = schema.allowedTypes;
+		kind = convertFieldKind.get(schema.kind)?.identifier ?? fail("Invalid field kind");
+		allowedTypes = schema.allowedTypes;
 	} else {
-		kind = FieldKinds.required;
-		types = schema;
+		kind = FieldKinds.required.identifier;
+		allowedTypes = schema;
 	}
-	const allowedTypes = convertAllowedTypes(schemaMap, types);
-	return FlexFieldSchema.create(kind, allowedTypes);
+	const types = convertAllowedTypes(allowedTypes);
+	return { kind, types };
 }
 
 const convertFieldKind = new Map<FieldKind, FlexFieldKind>([
@@ -142,123 +84,48 @@ const convertFieldKind = new Map<FieldKind, FlexFieldKind>([
 ]);
 
 /**
- * Normalizes an {@link ImplicitAllowedTypes} into an {@link AllowedTypes}.
+ * Normalizes an {@link ImplicitAllowedTypes} into an {@link TreeTypeSet}.
  */
-export function convertAllowedTypes(
-	schemaMap: SchemaMap,
-	schema: ImplicitAllowedTypes,
-): FlexAllowedTypes {
+export function convertAllowedTypes(schema: ImplicitAllowedTypes): TreeTypeSet {
 	if (isReadonlyArray(schema)) {
-		return normalizeFlexListEager(schema).map((item) => convertNodeSchema(schemaMap, item));
+		return new Set(normalizeFlexListEager(schema).map((item) => brand(item.identifier)));
 	}
-	return [convertNodeSchema(schemaMap, schema)];
+	return new Set([brand(schema.identifier)]);
 }
 
-const builder = { name: "simple schema" };
-
 /**
- * Converts a {@link TreeNodeSchema} into a {@link FlexTreeNodeSchema}.
- * Ensures all types reachable from `schema` are included in `schemaMap`.
- *
- * Return value (and entries in map) are lazy to allow recursive types to work.
- * This laziness does NOT extend to adding entries to `schemaMap`:
- * all referenced types are added to it before this function returns.
+ * Converts a {@link TreeNodeSchema} into a {@link TreeNodeStoredSchema}.
  */
-export function convertNodeSchema(
-	schemaMap: SchemaMap,
-	schema: TreeNodeSchema,
-): () => FlexTreeNodeSchema {
-	const fromMap = schemaMap.get(brand(schema.identifier));
-	if (fromMap !== undefined) {
-		if (fromMap.original !== schema) {
-			// Use JSON.stringify to quote and escape identifier string.
-			throw new UsageError(
-				`Multiple schema encountered with the identifier ${JSON.stringify(
-					schema.identifier,
-				)}. Remove or rename them to avoid the collision.`,
-			);
+export function getStoredSchema(schema: TreeNodeSchema): TreeNodeStoredSchema {
+	const kind = schema.kind;
+	switch (kind) {
+		case NodeKind.Leaf: {
+			assert(schema instanceof LeafNodeSchema, "invalid kind");
+			return new LeafNodeStoredSchema(schema.info);
 		}
-		return fromMap.toFlex;
-	}
-
-	const toFlex = (): FlexTreeNodeSchema => {
-		let out: FlexTreeNodeSchema;
-		const kind = schema.kind;
-		switch (kind) {
-			case NodeKind.Leaf: {
-				const cached =
-					cachedFlexSchemaFromClassSchema(schema) ?? fail("leaf schema should be pre-cached");
-				assert(schemaIsLeaf(cached), 0x840 /* expected leaf */);
-				return cached;
-			}
-			case NodeKind.Map: {
-				const fieldInfo = schema.info as ImplicitAllowedTypes;
-				const field = FlexFieldSchema.create(
-					FieldKinds.optional,
-					convertAllowedTypes(schemaMap, fieldInfo),
-				);
-				// Lookup of cached schema is done here instead of before since walking the schema recursively to populate schemaMap is still required.
-				const cached = cachedFlexSchemaFromClassSchema(schema);
-				out =
-					cached ??
-					FlexMapNodeSchema.create(
-						builder,
-						brand<TreeNodeSchemaIdentifier>(schema.identifier),
-						field,
-					);
-				break;
-			}
-			case NodeKind.Array: {
-				const fieldInfo = schema.info as ImplicitAllowedTypes;
-				const field = FlexFieldSchema.create(
-					FieldKinds.sequence,
-					convertAllowedTypes(schemaMap, fieldInfo),
-				);
-				const cached = cachedFlexSchemaFromClassSchema(schema);
-				out =
-					cached ??
-					FlexObjectNodeSchema.create(builder, brand(schema.identifier), {
-						[EmptyKey]: field,
-					});
-				break;
-			}
-			case NodeKind.Object: {
-				const info = schema.info as Record<string, ImplicitFieldSchema>;
-				const fields: Record<string, FlexFieldSchema> = Object.create(null);
-				for (const [propertyKey, implicitFieldSchema] of Object.entries(info)) {
-					// If a `stored key` was provided, use it as the key in the flex schema.
-					// Otherwise, use the property key.
-					const flexKey = getStoredKey(propertyKey, implicitFieldSchema);
-
-					// This code has to be careful to avoid assigning to __proto__ or similar built-in fields.
-					Object.defineProperty(fields, flexKey, {
-						enumerable: true,
-						configurable: false,
-						writable: false,
-						value: convertField(schemaMap, implicitFieldSchema),
-					});
-				}
-				const cached = cachedFlexSchemaFromClassSchema(schema);
-				out = cached ?? FlexObjectNodeSchema.create(builder, brand(schema.identifier), fields);
-				break;
-			}
-			default:
-				unreachableCase(kind);
+		case NodeKind.Map: {
+			const fieldInfo = schema.info as ImplicitAllowedTypes;
+			const types = convertAllowedTypes(fieldInfo);
+			return new MapNodeStoredSchema({ kind: FieldKinds.optional.identifier, types });
 		}
-		assert(out instanceof TreeNodeSchemaBase, 0x841 /* invalid schema produced */);
-		{
-			const cached = cachedFlexSchemaFromClassSchema(schema);
-			if (cached !== undefined) {
-				assert(
-					cachedFlexSchemaFromClassSchema(schema) === out,
-					0x842 /* incorrect flexSchemaSymbol */,
-				);
-			} else {
-				setFlexSchemaFromClassSchema(schema, out);
+		case NodeKind.Array: {
+			const fieldInfo = schema.info as ImplicitAllowedTypes;
+			const field = {
+				kind: FieldKinds.sequence.identifier,
+				types: convertAllowedTypes(fieldInfo),
+			};
+			const fields = new Map([[EmptyKey, field]]);
+			return new ObjectNodeStoredSchema(fields);
+		}
+		case NodeKind.Object: {
+			assert(isObjectNodeSchema(schema), "invalid kind");
+			const fields: Map<FieldKey, TreeFieldStoredSchema> = new Map();
+			for (const field of schema.flexKeyMap.values()) {
+				fields.set(field.storedKey, convertField(field.schema));
 			}
+			return new ObjectNodeStoredSchema(fields);
 		}
-		return out;
-	};
-	schemaMap.set(brand(schema.identifier), { original: schema, toFlex });
-	return toFlex;
+		default:
+			unreachableCase(kind);
+	}
 }

package/src/simple-tree/toMapTree.ts

@@ -20,7 +20,6 @@ import {
 	isTreeValue,
 	valueSchemaAllows,
 	type NodeKeyManager,
-	isMapTreeNode,
 } from "../feature-libraries/index.js";
 import { brand, fail, isReadonlyArray, find } from "../util/index.js";
 
@@ -39,13 +38,14 @@ import {
 } from "./schemaTypes.js";
 import {
 	getKernel,
-	getSimpleNodeSchemaFromNode,
+	getSimpleNodeSchemaFromInnerNode,
 	isTreeNode,
 	NodeKind,
 	type InnerNode,
 	type TreeNode,
 	type TreeNodeSchema,
 	type Unhydrated,
+	UnhydratedFlexTreeNode,
 } from "./core/index.js";
 import { SchemaValidationErrors, isNodeInSchema } from "../feature-libraries/index.js";
 import { isObjectNodeSchema } from "./objectNodeTypes.js";
@@ -161,8 +161,8 @@ function nodeDataToMapTree(
 	// They already have the mapTree, so there is no need to recompute it.
 	const innerNode = tryGetInnerNode(data);
 	if (innerNode !== undefined) {
-		if (isMapTreeNode(innerNode)) {
-			if (!allowedTypes.has(getSimpleNodeSchemaFromNode(innerNode))) {
+		if (innerNode instanceof UnhydratedFlexTreeNode) {
+			if (!allowedTypes.has(getSimpleNodeSchemaFromInnerNode(innerNode))) {
 				throw new UsageError("Invalid schema for this context.");
 			}
 			// TODO: mapTreeFromNodeData modifies the trees it gets to add defaults.
@@ -170,7 +170,7 @@ function nodeDataToMapTree(
 			// This is unnecessary and inefficient, but should be a no-op if all calls provide the same context (which they might not).
 			// A cleaner design (avoiding this cast) might be to apply defaults eagerly if they don't need a context, and lazily (when hydrating) if they do.
 			// This could avoid having to mutate the map tree to apply defaults, removing the need for this cast.
-			return innerNode.mapTree as ExclusiveMapTree;
+			return innerNode.mapTree;
 		} else {
 			// The node is already hydrated, meaning that it already got inserted into the tree previously
 			throw new UsageError("A node may not be inserted into the tree more than once");

package/src/simple-tree/treeNodeValid.ts

@@ -8,7 +8,6 @@ import { assert } from "@fluidframework/core-utils/internal";
 import {
 	type TreeNodeSchema,
 	NodeKind,
-	tryGetSimpleNodeSchema,
 	isTreeNode,
 	TreeNodeKernel,
 	privateToken,
@@ -16,17 +15,14 @@ import {
 	type InternalTreeNode,
 	typeSchemaSymbol,
 	type InnerNode,
+	type Context,
+	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import {
-	type FlexTreeNode,
-	type MapTreeNode,
-	isFlexTreeNode,
-	markEager,
-} from "../feature-libraries/index.js";
+import { type FlexTreeNode, isFlexTreeNode, markEager } from "../feature-libraries/index.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { fail } from "../util/index.js";
 
-import { getFlexSchema } from "./toFlexSchema.js";
+import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
 
 /**
  * Class which all {@link TreeNode}s must extend.
@@ -60,7 +56,7 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 		this: typeof TreeNodeValid<T>,
 		instance: TreeNodeValid<T>,
 		input: T,
-	): MapTreeNode {
+	): UnhydratedFlexTreeNode {
 		return fail("Schema must override buildRawNode");
 	}
 
@@ -68,7 +64,9 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 	 * Schema classes can override to provide a callback that is called once when the first node is constructed.
 	 * This is a good place to perform extra validation and cache schema derived data needed for the implementation of the node.
 	 */
-	protected static oneTimeSetup<T>(this: typeof TreeNodeValid<T>): void {}
+	protected static oneTimeSetup<T>(this: typeof TreeNodeValid<T>): Context {
+		fail("Missing oneTimeSetup");
+	}
 
 	/**
 	 * The most derived constructor (the one invoked with the `new` operator, not a parent class constructor invoked with as `super`) used to construct an instance of this type.
@@ -110,7 +108,7 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 				schemaBase = Reflect.getPrototypeOf(schemaBase) as typeof TreeNodeValid;
 			}
 			assert(schemaBase.constructorCached === undefined, 0x962 /* overwriting wrong cache */);
-			schemaBase.constructorCached = { constructor: this, oneTimeInitialized: false };
+			schemaBase.constructorCached = { constructor: this, oneTimeInitialized: undefined };
 			assert(
 				this.constructorCached === schemaBase.constructorCached,
 				0x9b5 /* Inheritance should work */,
@@ -129,18 +127,26 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 		);
 	}
 
+	/**
+	 * Node creation function for implementing the TreeNodeSchemaNonClass half of TreeNodeSchemaBoth.
+	 * @remarks
+	 * When used as TreeNodeSchemaNonClass and subclassed,
+	 * does not actually have the correct compile time type for the return value due to TypeScript limitations.
+	 * This is why this is not exposed as part of TreeNodeSchemaCLass where subclassing is allowed.
+	 */
+	public static create<TInput, TOut, TThis extends new (args: TInput) => TOut>(
+		this: TThis,
+		input: TInput,
+	): TOut {
+		return new this(input);
+	}
+
 	public constructor(input: TInput | InternalTreeNode) {
 		super(privateToken);
 		const schema = this.constructor as typeof TreeNodeValid & TreeNodeSchema;
 		const cache = schema.markMostDerived();
-		if (!cache.oneTimeInitialized) {
-			const flexSchema = getFlexSchema(schema);
-			assert(
-				tryGetSimpleNodeSchema(flexSchema) === schema,
-				0x961 /* Schema class not properly configured */,
-			);
-			schema.oneTimeSetup();
-			cache.oneTimeInitialized = true;
+		if (cache.oneTimeInitialized === undefined) {
+			cache.oneTimeInitialized = schema.oneTimeSetup();
 		}
 
 		if (isTreeNode(input)) {
@@ -152,7 +158,7 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 
 		const node: InnerNode = isFlexTreeNode(input) ? input : schema.buildRawNode(this, input);
 		assert(
-			tryGetSimpleNodeSchema(node.flexSchema) === schema,
+			getSimpleNodeSchemaFromInnerNode(node) === schema,
 			0x83b /* building node with wrong schema */,
 		);
 
@@ -160,7 +166,7 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 		// The TreeNodeKernel associates itself the TreeNode (result here, not node) so it can be looked up later via getKernel.
 		// If desired this could be put in a non-enumerable symbol property for lookup instead, but that gets messy going through proxies,
 		// so just relying on the WeakMap seems like the cleanest approach.
-		new TreeNodeKernel(result, schema, node);
+		new TreeNodeKernel(result, schema, node, cache.oneTimeInitialized);
 
 		return result;
 	}
@@ -181,7 +187,7 @@ markEager(TreeNodeValid);
  */
 export interface MostDerivedData {
 	readonly constructor: typeof TreeNodeValid & TreeNodeSchema;
-	oneTimeInitialized: boolean;
+	oneTimeInitialized?: Context;
 }
 
 // #region NodeJS custom inspect for TreeNodes.

package/src/simple-tree/typesUnsafe.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FlexListToUnion, Unenforced } from "../feature-libraries/index.js";
-import type { RestrictiveReadonlyRecord, _InlineTrick } from "../util/index.js";
+import type { RestrictiveStringRecord, _InlineTrick } from "../util/index.js";
 
 import type {
 	AllowedTypes,
@@ -44,7 +44,7 @@ import type { TreeArrayNodeBase, TreeArrayNode } from "./arrayNode.js";
  * @system @public
  */
 export type ObjectFromSchemaRecordUnsafe<
-	T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
+	T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,
 > = {
 	-readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;
 };
@@ -56,7 +56,7 @@ export type ObjectFromSchemaRecordUnsafe<
  * @system @public
  */
 export type TreeObjectNodeUnsafe<
-	T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
+	T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,
 	TypeName extends string = string,
 > = TreeNode & ObjectFromSchemaRecordUnsafe<T> & WithType<TypeName, NodeKind.Object>;
 
@@ -230,7 +230,7 @@ export type FieldHasDefaultUnsafe<T extends Unenforced<ImplicitFieldSchema>> =
  * @system @public
  */
 export type InsertableObjectFromSchemaRecordUnsafe<
-	T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
+	T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,
 > = {
 	// Field might not have a default, so make it required:
 	readonly [Property in keyof T as FieldHasDefaultUnsafe<T[Property]> extends false

package/src/simple-tree/walkFieldSchema.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type TreeNodeSchema, walkAllowedTypes, type SchemaVisitor } from "./core/index.js";
+
+import { type ImplicitFieldSchema, normalizeFieldSchema } from "./schemaTypes.js";
+
+/**
+ * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.
+ */
+export function walkFieldSchema(
+	schema: ImplicitFieldSchema,
+	visitor: SchemaVisitor,
+	visitedSet: Set<TreeNodeSchema> = new Set(),
+): void {
+	walkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);
+}

package/src/util/index.ts

@@ -94,13 +94,9 @@ export {
 export { ReferenceCountedBase, type ReferenceCounted } from "./referenceCounting.js";
 
 export type {
-	AllowOptional,
-	RequiredFields,
-	OptionalFields,
 	_RecursiveTrick,
-	AllowOptionalNotFlattened,
 	RestrictiveReadonlyRecord,
-	Assume,
+	RestrictiveStringRecord,
 	_InlineTrick,
 	FlattenKeys,
 } from "./typeUtils.js";

package/src/util/typeUtils.ts

@@ -14,52 +14,6 @@
  */
 export type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTrick];
 
-/**
- * Remove all fields which permit undefined from `T`.
- */
-export type RequiredFields<T> = [
-	{
-		[P in keyof T as undefined extends T[P] ? never : P]: T[P];
-	},
-][_InlineTrick];
-
-/**
- * Extract fields which permit undefined but can also hold other types.
- */
-export type OptionalFields<T> = [
-	{
-		[P in keyof T as undefined extends T[P]
-			? T[P] extends undefined
-				? never
-				: P
-			: never]?: T[P];
-	},
-][_InlineTrick];
-
-/**
- * Converts properties of an object which permit undefined into optional properties.
- * Removes fields which only allow undefined.
- *
- * @remarks
- * This version does not flatten the resulting type.
- * This version exists because some cases recursive types need to avoid this
- * flattening since it causes complication issues.
- *
- * See also `AllowOptional`.
- */
-// export type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];
-export type AllowOptionalNotFlattened<T> = [
-	RequiredFields<T> & OptionalFields<T>,
-][_InlineTrick];
-
-/**
- * Converts properties of an object which permit undefined into optional properties.
- * Removes fields which only allow undefined.
- */
-export type AllowOptional<T> = [
-	FlattenKeys<RequiredFields<T> & OptionalFields<T>>,
-][_InlineTrick];
-
 /**
  * Use for trick to "inline" generic types.
  *
@@ -157,9 +111,15 @@ export type _RecursiveTrick = never;
  * Alternative to the built in Record type which does not permit unexpected members,
  * and is readonly.
  *
+ * @remarks
+ * This does not work correctly when `K` is more specific than `string` or `symbol`.
+ * For example `{a: 5}` is not assignable to `RestrictiveReadonlyRecord<"a",: number>`
+ *
  * @privateRemarks
  * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.
  * The cause for this is unclear, but empirically it was the case when this comment was written.
+ *
+ * @deprecated Use a more robust / specific type instead. This type never worked as intended.
  * @public
  */
 export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
@@ -167,15 +127,13 @@ export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
 };
 
 /**
- * Assume that `TInput` is a `TAssumeToBe`.
- *
+ * Alternative to the built-in `Record<string, T>` type which is readonly and does not permit symbols.
  * @remarks
- * This is useful in generic code when it is impractical (or messy)
- * to to convince the compiler that a generic type `TInput` will extend `TAssumeToBe`.
- * In these cases `TInput` can be replaced with `Assume<TInput, TAssumeToBe>` to allow compilation of the generic code.
- * When the generic code is parameterized with a concrete type, if that type actually does extend `TAssumeToBe`,
- * it will behave like `TInput` was used directly.
+ * It would be nice if `keyof RestrictiveStringRecord<T>` returned string, but it does not: use `keyof RestrictiveStringRecord<T> & string` instead.
+ * @system @public
  */
-export type Assume<TInput, TAssumeToBe> = [TInput] extends [TAssumeToBe]
-	? TInput
-	: TAssumeToBe;
+export type RestrictiveStringRecord<T> = {
+	readonly [P in string]: T;
+} & {
+	readonly [P in symbol]?: never;
+};