@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/model-fragments.d.ts

@@ -0,0 +1,294 @@
+import { a as WithArrayLike, o as WithEmberObject } from "./extensions-DumNm4dA.js";
+import { Store } from "@warp-drive/core";
+import { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
+import { ModelSchema, SchemaService } from "@warp-drive/core/types";
+import { TypeFromInstance, TypedRecordInstance } from "@warp-drive/core/types/record";
+import { LegacyAttributeField, LegacyRelationshipField, LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import { WithPartial } from "@warp-drive/core/types/utils";
+import "@ember/application/instance";
+//#region src/model-fragments/utilities/with-array-defaults.d.ts
+/**
+ * Used as a helper to setup the relevant parts of an array
+ * schema and add extensions etc.
+ *
+ * @param arrayName The name of the array
+ * @param primitiveType The primitive type of items in the array (optional)
+ * @returns The schema for an array
+ */
+declare function withArrayDefaults<ArrayName extends string, PrimitiveType extends string>(arrayName: ArrayName, primitiveType?: PrimitiveType): PrimitiveType extends undefined ? {
+  /**
+   * This field is an `'array'` schema field.
+   */
+  kind: "array";
+  /**
+   * The name of the array field.
+   */
+  name: ArrayName;
+  /**
+   * The array's item type, `'array'` since no `primitiveType` was given.
+   */
+  type: "array";
+  /**
+   * The schema options for this array field.
+   */
+  options: {
+    /**
+     * The registered array-schema extensions to apply to this array.
+     */
+    arrayExtensions: string[];
+  };
+} : {
+  /**
+   * This field is an `'array'` schema field.
+   */
+  kind: "array";
+  /**
+   * The name of the array field.
+   */
+  name: ArrayName;
+  /**
+   * The array's item type, derived from `primitiveType`.
+   */
+  type: `array:${PrimitiveType}`;
+  /**
+   * The schema options for this array field.
+   */
+  options: {
+    /**
+     * The registered array-schema extensions to apply to this array.
+     */
+    arrayExtensions: string[];
+  };
+};
+//#endregion
+//#region src/model-fragments/utilities/with-fragment-defaults.d.ts
+/**
+ * Used as a helper to setup the relevant parts of a fragment schema
+ * and add extensions etc.
+ *
+ * @param fragmentType The type of the fragment
+ * @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
+ * @returns The schema for a fragment
+ */
+declare function withFragmentDefaults<FragmentType extends string, FragmentName extends string>(fragmentType: FragmentType, fragmentName?: FragmentName): {
+  /**
+   * This field is a `'schema-object'` field, a single fragment.
+   */
+  kind: "schema-object";
+  /**
+   * The resource type of the fragment.
+   */
+  type: `fragment:${FragmentType}`;
+  /**
+   * The name of the fragment field.
+   */
+  name: FragmentType | FragmentName;
+  /**
+   * The schema options for this fragment field.
+   */
+  options: {
+    /**
+     * The registered object-schema extensions to apply to this fragment.
+     */
+    objectExtensions: string[];
+  };
+};
+//#endregion
+//#region src/model-fragments/utilities/with-fragment-array-defaults.d.ts
+/**
+ * Used as a helper to setup the relevant parts of a fragment-array
+ * schema and add extensions etc.
+ *
+ * @param fragmentArrayType The type of the fragment-array
+ * @param fragmentArrayName The name of the fragment-array
+ * @returns The schema for a fragment-array
+ */
+declare function withFragmentArrayDefaults<FragmentArrayType extends string, FragmentArrayName extends string>(fragmentArrayType: FragmentArrayType, fragmentArrayName?: FragmentArrayName): {
+  /**
+   * This field is a `'schema-array'` field, an array of fragments.
+   */
+  kind: "schema-array";
+  /**
+   * The resource type of the fragments contained in this array.
+   */
+  type: `fragment:${string}`;
+  /**
+   * The name of the fragment-array field.
+   */
+  name: string;
+  /**
+   * The schema options for this fragment-array field.
+   */
+  options: {
+    /**
+     * The registered array-schema extensions to apply to this array.
+     */
+    arrayExtensions: string[];
+    /**
+     * Whether the array defaults to a non-null empty array when unset.
+     */
+    defaultValue: boolean;
+  };
+};
+//#endregion
+//#region src/model-fragments/utilities/with-legacy.d.ts
+/**
+ * Used as a helper to setup the relevant parts of a legacy resource schema
+ * migrated from `Model`, applying the `ember-object` and `fragment` object
+ * extensions and a default `@id` identity field.
+ *
+ * @param schema the partial legacy resource schema to complete
+ * @returns the completed resource schema
+ */
+declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;
+//#endregion
+//#region src/model-fragments/instance-initializers/fragment-extensions.d.ts
+/**
+ * Registers the {@link FragmentExtension}/{@link FragmentArrayExtension} schema
+ * extensions on the given `SchemaService`, enabling ModelFragments migration support.
+ *
+ * @public
+ */
+declare function registerFragmentExtensions(schema: SchemaService): void;
+//#endregion
+//#region src/model-fragments/hooks/model-for.d.ts
+type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+  __store: Store;
+  modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+  constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+  get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+  get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+  get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+  eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+  eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+  eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+declare function fragmentsModelFor<T extends TypedRecordInstance>(this: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+/**
+ * The `modelFor` fallback used to construct a `ShimModelClass` schema for a
+ * type when ModelFragments support is enabled and no real `Model` subclass
+ * is registered for that type.
+ *
+ * @public
+ */
+declare const modelFor: typeof fragmentsModelFor;
+//#endregion
+//#region src/model-fragments/extensions/fragment.d.ts
+/**
+ * The features added to an object resource by {@link FragmentExtension}, providing
+ * a subset of the legacy `ModelFragments` fragment API for migrated resources.
+ */
+declare class Fragment {
+  /**
+   * Whether this fragment is in the process of being destroyed.
+   */
+  isDestroying: boolean;
+  /**
+   * Whether this fragment has been destroyed.
+   */
+  isDestroyed: boolean;
+  /**
+   * Whether this fragment (or the attribute it is rooted at) has uncommitted changes.
+   */
+  get hasDirtyAttributes(): boolean;
+  /**
+   * Always `true`. Used to distinguish fragments from other resources.
+   */
+  get isFragment(): boolean;
+  /**
+   * The resource type of this fragment, if known.
+   */
+  get $type(): string | null | undefined;
+  /**
+   * Reverts this fragment's attribute back to its last known remote value.
+   */
+  rollbackAttributes(this: PrivateReactiveResource): void;
+}
+/**
+ * A schema extension that adds the {@link Fragment} API to migrated
+ * `ModelFragments` object resources.
+ */
+declare const FragmentExtension: {
+  /**
+   * This extension applies to `'object'` schemas.
+   */
+  kind: "object";
+  /**
+   * The registered name of this extension.
+   */
+  name: "fragment";
+  /**
+   * The features ({@link Fragment}) added by this extension.
+   */
+  features: typeof Fragment;
+};
+//#endregion
+//#region src/model-fragments/extensions/fragment-array.d.ts
+/**
+ * The features added to an array resource by {@link FragmentArrayExtension}, providing
+ * a subset of the legacy `ModelFragments` fragment-array API for migrated resources.
+ */
+declare class FragmentArray<T extends Fragment> {
+  /**
+   * Whether this fragment array is in the process of being destroyed.
+   */
+  isDestroying: boolean;
+  /**
+   * Whether this fragment array has been destroyed.
+   */
+  isDestroyed: boolean;
+  /**
+   * Whether this fragment array (or any of its members) has uncommitted changes.
+   */
+  get hasDirtyAttributes(): boolean;
+  /**
+   * Adds an existing fragment to this array, if one was given.
+   */
+  addFragment(fragment?: T): Fragment[] | undefined;
+  /**
+   * Appends a new fragment to the end of this array, if one was given.
+   */
+  createFragment(fragment?: T): Fragment | undefined;
+  /**
+   * Removes the given fragment from this array, if present.
+   */
+  removeFragment(fragment?: T): void;
+  /**
+   * Reverts each member fragment's attribute back to its last known remote value.
+   */
+  rollbackAttributes(): void;
+}
+/**
+ * A schema extension that adds the {@link FragmentArray} API to migrated
+ * `ModelFragments` array resources.
+ */
+declare const FragmentArrayExtension: {
+  /**
+   * This extension applies to `'array'` schemas.
+   */
+  kind: "array";
+  /**
+   * The registered name of this extension.
+   */
+  name: "fragment-array";
+  /**
+   * The features ({@link FragmentArray}) added by this extension.
+   */
+  features: typeof FragmentArray;
+};
+//#endregion
+//#region src/model-fragments/index.d.ts
+/**
+ * Adds the classic `EmberObject` API (via {@link WithEmberObject}) and the
+ * {@link Fragment} API to the type of a migrated single-fragment resource.
+ */
+type WithFragment<T> = T & WithEmberObject<T> & Fragment;
+/**
+ * Adds Ember's classic array-like API (via {@link WithArrayLike}) and the
+ * {@link FragmentArray} API to the type of a migrated fragment-array resource.
+ */
+type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;
+//#endregion
+export { Fragment, FragmentArray, FragmentArrayExtension, FragmentExtension, type WithFragment, type WithFragmentArray, modelFor, registerFragmentExtensions, withArrayDefaults, withFragmentArrayDefaults, withFragmentDefaults, withLegacy };
+//# sourceMappingURL=model-fragments.d.ts.map

package/dist/model-fragments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-fragments.d.ts","names":[],"sources":["../src/model-fragments/utilities/with-array-defaults.ts","../src/model-fragments/utilities/with-fragment-defaults.ts","../src/model-fragments/utilities/with-fragment-array-defaults.ts","../src/model-fragments/utilities/with-legacy.ts","../src/model-fragments/instance-initializers/fragment-extensions.ts","../src/model-fragments/hooks/model-for.ts","../src/model-fragments/extensions/fragment.ts","../src/model-fragments/extensions/fragment-array.ts","../src/model-fragments/index.ts"],"mappings":";;;;;;;;;;;;;;;;;iBAQgB,kBAAkB,0BAA0B,8BAC1D,WAAW,WACX,gBAAgB,gBACf;;;;EAKG;;;;EAIA,MAAM;;;;EAIN;;;;EAIA;;;;IAIE;;;;;;EAOF;;;;EAIA,MAAM;;;;EAIN,eAAe;;;;EAIf;;;;IAIE;;;;;;;;;;;;;iBC/CQ,qBAAqB,6BAA6B,6BAChE,cAAc,cACd,eAAe;;;;EAKf;;;;EAIA,kBAAkB;;;;EAIlB,MAAM,eAAe;;;;EAIrB;;;;IAIE;;;;;;;;;;;;;iBCrBY,0BAA0B,kCAAkC,kCAC1E,mBAAmB,mBACnB,oBAAoB;;;;EAKpB;;;;EAIA;;;;EAIA;;;;EAIA;;;;IAIE;;;;IAIA;;;;;;;;;;;;;iBCxBY,WAAW,QAAQ,YAAY,+CAA+C;;;;;;;;;iBCC9E,2BAA2B,QAAQ;;;KCR9C,YAAY,WAAW,0CAA0C;cA4BzD,eAAe,wBAAwB,YAAY;EAC9D,SAAiB;EACjB,WAAmB,UAAU,sBAAsB,iBAAiB;EACpE,YAAY,OAAO,OAAO,WAAW,UAAU,sBAAsB,iBAAiB;MAKlF,UAAU,IAAI,YAAY;MAgB1B,cAAc,IAAI,YAAY,IAAI;MAqBlC,uBAAuB,IAAI,YAAY,IAAI;EAa/C,cAAc,UAAU,YAAY,IAClC,WAAW,KAAK,GAAG,WAAW,+BAC9B,UAAU;EAOZ,iBAAiB,UAAU,YAAY,IACrC,WAAW,KAAK,GAAG,cAAc,kCACjC,UAAU;EASZ,yBAAyB,UAAU,YAAY,IAC7C,WAAW,KAAK,GAAG,8BACnB,UAAU;;iBAWE,kBAAkB,UAAU,qBAAA,MACpC,OACN,WAAW,UAAU,sBAAsB,iBAAiB,cAC3D,eAAe;;;;;;;;cAWL,iBAAiB;;;;;;;cC9HjB;;;;EAKX;;;;EAIA;;;;MAMI;;;;MAeA;;;;MAOA;;;;EAQJ,mBAAA,MAAyB;;;;;;cAcd;;;;EAIX;;;;EAIA;;;;EAIA,iBAAiB;;;;;;;;cCvEN,cAAc,UAAU;;;;EAKnC;;;;EAIA;;;;MAMI;;;;EAiBJ,YAAY,WAAW,IAAI;;;;EAW3B,eAAe,WAAW,IAAI;;;;EAW9B,eAAe,WAAW;;;;EAe1B;;;;;;cAYW;;;;EAIX;;;;EAIA;;;;EAIA,iBAAiB;;;;;;;;KClGP,aAAa,KAAK,IAAI,gBAAgB,KAAK;;;;;KAK3C,kBAAkB,UAAU,YAAY,IAAI,cAAc,KAAK,cAAc"}

package/dist/model-fragments.js

@@ -1,76 +1,3 @@
-import { singularize, pluralize } from '@warp-drive/utilities/string';
-import { withDefaults } from './model/migration-support.js';
-import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-CqXsIKws.js";
-export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-CqXsIKws.js";
+import { a as FragmentExtension, c as withLegacy, d as withArrayDefaults, i as Fragment, l as withFragmentArrayDefaults, n as modelFor, o as FragmentArray, r as registerFragmentExtensions, s as FragmentArrayExtension, u as withFragmentDefaults } from "./model-fragments-DSqu0ptR.js";
 
-/**
- * Used as a helper to setup the relevant parts of an array
- * schema and add extensions etc.
- *
- * @param arrayName The name of the array
- * @returns The schema for an array
- */
-function withArrayDefaults(arrayName) {
-  return {
-    kind: 'array',
-    name: arrayName,
-    type: `array:${singularize(arrayName)}`,
-    options: {
-      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array']
-    }
-  };
-}
-
-/**
- * Used as a helper to setup the relevant parts of a fragment schema
- * and add extensions etc.
- *
- * @param fragmentType The type of the fragment
- * @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
- * @returns The schema for a fragment
- */
-function withFragmentDefaults(fragmentType, fragmentName) {
-  return {
-    kind: 'schema-object',
-    type: `fragment:${fragmentType}`,
-    name: fragmentName ?? fragmentType,
-    options: {
-      objectExtensions: ['ember-object', 'fragment']
-    }
-  };
-}
-
-/**
- * Used as a helper to setup the relevant parts of a fragment-array
- * schema and add extensions etc.
- *
- * @param fragmentArrayType The type of the fragment-array
- * @param fragmentArrayName The name of the fragment-array
- * @returns The schema for a fragment-array
- */
-function withFragmentArrayDefaults(fragmentArrayType, fragmentArrayName) {
-  return {
-    kind: 'schema-array',
-    type: `fragment:${singularize(fragmentArrayType)}`,
-    name: fragmentArrayName ?? pluralize(fragmentArrayType),
-    options: {
-      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array'],
-      defaultValue: true
-    }
-  };
-}
-function withLegacy(schema) {
-  return withDefaults({
-    ...schema,
-    identity: {
-      kind: '@id',
-      name: 'id'
-    },
-    objectExtensions: ['ember-object', 'fragment']
-  });
-}
-function registerFragmentExtensions(schema) {
-  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
-  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
-}
-export { FragmentArrayExtension, FragmentExtension, registerFragmentExtensions, withArrayDefaults, withFragmentArrayDefaults, withFragmentDefaults, withLegacy };
+export { Fragment, FragmentArray, FragmentArrayExtension, FragmentExtension, modelFor, registerFragmentExtensions, withArrayDefaults, withFragmentArrayDefaults, withFragmentDefaults, withLegacy };