@warp-drive/legacy 5.8.0-alpha.9 → 5.8.0-beta.1

package/dist/{hooks-Bp8SIQBU.js → hooks-D6diaM34.js}

@@ -1,6 +1,6 @@
 import { setOwner, getOwner } from '@ember/application';
 import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
-import { g as getModelFactory } from "./schema-provider-JlCneqZH.js";
+import { g as getModelFactory } from "./schema-provider-DJCV_6AF.js";
 import { n as normalizeModelName } from "./util-Dul6TZts.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 function instantiateRecord(identifier, createRecordArgs) {

package/dist/index.js

@@ -9,10 +9,11 @@ import '@ember/debug';
 import '@warp-drive/utilities/string';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import '@warp-drive/core/store/-private';
-import "./errors-COviC59J.js";
-import "./schema-provider-JlCneqZH.js";
-import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-Bp8SIQBU.js";
+import "./errors-Cz5KrzBk.js";
+import "./schema-provider-DJCV_6AF.js";
+import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-D6diaM34.js";
 import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
+import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-CqXsIKws.js";
 import { restoreDeprecatedStoreBehaviors } from './store.js';
 
 /**
@@ -29,7 +30,9 @@ function useLegacyStore(options, StoreKlass = Store) {
       throw new Error(`If legacyRequests is true, linksMode must be false`);
     }
   })(!(options.linksMode && options.legacyRequests)) : {};
-  class LegacyConfiguredStore extends StoreKlass {
+  // we extend the store to ensure we don't leak our prototype overrides to other stores below.
+  class BaseKlass extends StoreKlass {}
+  class LegacyConfiguredStore extends BaseKlass {
     requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...(options.handlers ?? []), Fetch].filter(Boolean)).useCache(CacheHandler);
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
@@ -82,6 +85,12 @@ function useLegacyStore(options, StoreKlass = Store) {
       schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectArrayExtension);
       schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectExtension);
 
+      // add support for fragments
+      if (options.modelFragments) {
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+      }
+
       // Add fallback for Models
       return new DelegatingSchemaService(this, schema);
     }
@@ -104,14 +113,22 @@ function useLegacyStore(options, StoreKlass = Store) {
     }
     modelFor(type) {
       assertType(this.schema, type);
+      // TODO I'm not sure this is right
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
         if (!test) {
-          throw new Error(`modelFor should only be used to lookup legacy models when in linksMode`);
+          throw new Error(`modelFor should only be used to lookup legacy models when in linksMode: false`);
         }
-      })(!options.linksMode || this.schema.isDelegated({
+      })(!options.linksMode || !this.schema.isDelegated({
         type
       })) : {};
-      return modelFor.call(this, type) || super.modelFor(type);
+      const klass =
+      // prefer real models if present
+      modelFor.call(this, type) || (
+      // fallback to ShimModelClass specific to fragments if fragments support in use
+      options.modelFragments ? fragmentsModelFor.call(this, type) : false) ||
+      // fallback to ShimModelClass
+      super.modelFor(type);
+      return klass;
     }
     adapterFor(modelName, _allowMissing) {
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -162,7 +179,7 @@ function useLegacyStore(options, StoreKlass = Store) {
     }
   }
   if (options.legacyRequests) {
-    restoreDeprecatedStoreBehaviors(LegacyConfiguredStore);
+    restoreDeprecatedStoreBehaviors(BaseKlass);
   }
   return LegacyConfiguredStore;
 }

package/dist/{json-ksWOHRfq.js → json-ChdEfB0X.js}

@@ -44,7 +44,7 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
   For example, given the following `User` model and JSON payload:
 
   ```js [app/models/user.js]
-  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+  import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
 
   export default class UserModel extends Model {
     @hasMany('user') friends;
@@ -65,8 +65,8 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
   }
   ```
 
-  `JSONSerializer` will normalize the JSON payload to the JSON API format that the
-  Ember Data store expects.
+  `JSONSerializer` will normalize the JSON payload to the {json:api} format that the
+  JSONAPICache uses to cache data in the Store.
 
   You can customize how JSONSerializer processes its payload by passing options in
   the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:
@@ -101,7 +101,7 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
 const JSONSerializer = Serializer.extend({
   /**
     The `primaryKey` is used when serializing and deserializing
-    data. Ember Data always uses the `id` property to store the id of
+    data. WarpDrive always uses the `id` property to store the id of
     the record. The external source may not always follow this
     convention. In these cases it is useful to override the
     `primaryKey` property to match the `primaryKey` of your external
@@ -113,9 +113,7 @@ const JSONSerializer = Serializer.extend({
       primaryKey = '_id'
     }
     ```
-     @property primaryKey
-    @type {String}
-    @public
+     @public
     @default 'id'
   */
   primaryKey: 'id',
@@ -127,7 +125,7 @@ const JSONSerializer = Serializer.extend({
     the response payload.
      Example
      ```js [app/models/person.js]
-    import Model, { attr } from '@ember-data/model';
+    import Model, { attr } from '@warp-drive/legacy/model';
      export default class PersonModel extends Model {
       @attr('string') firstName;
       @attr('string') lastName;
@@ -157,7 +155,7 @@ const JSONSerializer = Serializer.extend({
     }
     ```
      When serialized:
-     ```javascript
+     ```js
     {
       "firstName": "Harry",
       "lastName": "Houdini",
@@ -168,9 +166,7 @@ const JSONSerializer = Serializer.extend({
      Setting `serialize` to `true` enforces serialization for hasMany
     relationships even if it's neither a many-to-many nor many-to-none
     relationship.
-     @property attrs
-    @public
-    @type {Object}
+     @public
   */
   mergedProperties: ['attrs'],
   /**
@@ -455,9 +451,6 @@ const JSONSerializer = Serializer.extend({
     }
     ```
      @public
-    @param {Model} typeClass
-    @param {Object} hash
-    @return {Object}
   */
   normalize(modelClass, resourceHash) {
     let data = null;
@@ -503,9 +496,6 @@ const JSONSerializer = Serializer.extend({
     Returns the resource's attributes formatted as a JSON-API "attributes object".
      http://jsonapi.org/format/#document-resource-object-attributes
      @public
-    @param {Object} modelClass
-    @param {Object} resourceHash
-    @return {Object}
   */
   extractAttributes(modelClass, resourceHash) {
     let attributeKey;
@@ -646,8 +636,7 @@ const JSONSerializer = Serializer.extend({
   /**
     Dasherizes the model name in the payload
      @public
-    @param {String} key
-    @return {String} the model's modelName
+    @return the model's modelName
   */
   modelNameFromPayloadKey(key) {
     return dasherize(singularize(key));
@@ -771,7 +760,7 @@ const JSONSerializer = Serializer.extend({
     each attribute and belongsTo relationship.
      For example, consider this model:
      ```js [app/models/comment.js]
-    import Model, { attr, belongsTo } from '@ember-data/model';
+    import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
      export default class CommentModel extends Model {
       @attr title;
       @attr body;
@@ -906,7 +895,7 @@ const JSONSerializer = Serializer.extend({
     The hash property should be modified by reference.
      For example, your server may expect underscored root objects.
      ```js [app/serializers/application.js]
-    import RESTSerializer from '@ember-data/serializer/rest';
+    import RESTSerializer from '@warp-drive/legacy/serializer/rest';
     import { underscoren} from '<app-name>/utils/string-utils';
      export default class ApplicationSerializer extends RESTSerializer {
       serializeIntoHash(data, type, snapshot, options) {
@@ -1160,11 +1149,7 @@ const JSONSerializer = Serializer.extend({
     }
     ```
      @public
-    @param {Store} store
-    @param {Model} typeClass
-    @param {Object} payload
-    @param {(String|Number)} id
-    @return {Object} json The deserialized errors
+    @return json The deserialized errors
   */
   extractErrors(store, typeClass, payload, id) {
     // @ts-expect-error

package/dist/model/-private.js

@@ -1 +1 @@
-export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-COviC59J.js";
+export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-Cz5KrzBk.js";

package/dist/model/migration-support.js

@@ -1,23 +1,24 @@
 import { deprecate } from '@ember/debug';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { Context } from '@warp-drive/core/reactive/-private';
-import { notifyInternalSignal, assertPrivateStore } from '@warp-drive/core/store/-private';
+import { notifyInternalSignal } from '@warp-drive/core/signals/-leaked';
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { Type } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, E as Errors } from "../errors-COviC59J.js";
-import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, i as deleteRecord, R as RecordState, j as changedAttributes, k as belongsTo, l as createSnapshot } from "../schema-provider-JlCneqZH.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-Cz5KrzBk.js";
+import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, i as deleteRecord, R as RecordState, j as changedAttributes, k as belongsTo, l as createSnapshot } from "../schema-provider-DJCV_6AF.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
- * This module provides support for migrating away from @ember-data/model
- * to @warp-drive/schema-record.
+ * This module provides support for migrating away from @warp-drive/legacy/model
+ * to ReactiveResource from @warp-drive/core/reactive.
  *
  * It includes:
  *
  * - A `withDefaults` function to assist in creating a schema in LegacyMode
  * - A `registerDerivations` function to register the derivations necessary to support LegacyMode
  * - A `DelegatingSchemaService` that can be used to provide a schema service that works with both
- *   @ember-data/model and @warp-drive/schema-record simultaneously for migration purposes.
+ *   @warp-drive/legacy/model and @warp-drive/core/reactive simultaneously for migration purposes.
  * - A `WithLegacy` type util that can be used to create a type that includes the legacy
  *   properties and methods of a record.
  *
@@ -32,14 +33,14 @@ const LegacyFields = ['_createSnapshot', 'adapterError', 'belongsTo', 'changedAt
 
 /**
  * A Type utility that enables quickly adding type information for the fields
- * defined by `import { withDefaults } from '@ember-data/model/migration-support'`.
+ * defined by `import { withDefaults } from '@warp-drive/legacy/model/migration-support'`.
  *
  * Example:
  *
  * ```ts
- * import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
- * import { Type } from '@warp-drive/core-types/symbols';
- * import type { HasMany } from '@ember-data/model';
+ * import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+ * import { Type } from '@warp-drive/core/types/symbols';
+ * import type { HasMany } from '@@warp-drive/legacy/model';
  *
  * export const UserSchema = withDefaults({
  *   type: 'user',
@@ -156,14 +157,14 @@ legacySupport[Type] = '@legacy';
 /**
  * A function which adds the necessary fields to a schema and marks it as
  * being in LegacyMode. This is used to support the legacy features of
- * @ember-data/model while migrating to WarpDrive.
+ * @warp-drive/legacy/model while migrating to WarpDrive.
  *
  * Example:
  *
  * ```ts
- * import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
- * import { Type } from '@warp-drive/core-types/symbols';
- * import type { HasMany } from '@ember-data/model';
+ * import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+ * import { Type } from '@warp-drive/core/types/symbols';
+ * import type { HasMany } from '@warp-drive/legacy/model';
  *
  * export const UserSchema = withDefaults({
  *   type: 'user',
@@ -198,13 +199,13 @@ legacySupport[Type] = '@legacy';
  * it requires with the schema service.
  *
  * ```ts
- * import { registerDerivations } from '@ember-data/model/migration-support';
+ * import { registerDerivations } from '@warp-drive/legacy/model/migration-support';
  *
  * registerDerivations(schema);
  * ```
  *
- * @param {LegacyResourceSchema} schema The schema to add legacy support to.
- * @return {LegacyResourceSchema} The schema with legacy support added.
+ * @param schema The schema to add legacy support to.
+ * @return The schema with legacy support added.
  * @public
  */
 function withDefaults(schema) {
@@ -248,6 +249,26 @@ function withDefaults(schema) {
   schema.objectExtensions.push('deprecated-model-behaviors');
   return schema;
 }
+
+/**
+ * Adds the necessasary fields to the schema for supporting
+ * the deprecated request methods on LegacyMode schemas.
+ *
+ * Use this instead of `withDefaults` to add the fields
+ * and behaviors necessary to support Model-Like capabilities.
+ *
+ * ```ts
+ * import { withRestoredDeprecatedModelRequestBehaviors } from '@warp-drive/legacy/model/migration-support';
+ *
+ * export const UserSchema = withRestoredDeprecatedModelRequestBehaviors({
+ *   type: 'user',
+ *   fields: [
+ *     { name: 'firstName', kind: 'attribute' },
+ *     { name: 'lastName', kind: 'attribute' },
+ *   ]
+ * });
+ * ```
+ */
 function withRestoredDeprecatedModelRequestBehaviors(schema) {
   schema.legacy = true;
   schema.identity = {
@@ -293,13 +314,10 @@ function withRestoredDeprecatedModelRequestBehaviors(schema) {
 
 /**
  * A function which registers the necessary derivations to support
- * the LegacyMode features of @ember-data/model while migrating to WarpDrive.
- *
- * This must be called in order to use the fields added by:
+ * the LegacyMode features of @warp-drive/legacy/model while migrating to WarpDrive.
  *
- * ```ts
- * import { withDefaults } from '@ember-data/model/migration-support';
- * ```
+ * This must be called in order to use the fields added by {@link withDefaults} or
+ * {@link withRestoredDeprecatedModelRequestBehaviors}.
  *
  * @param schema The schema service to register the derivations with.
  * @public
@@ -398,8 +416,8 @@ function registerDerivations(schema) {
  * provide their own schema information to the application.
  *
  * ```ts
- * import { DelegatingSchemaService } from '@ember-data/model/migration-support';
- * import { SchemaService } from '@warp-drive/schema-record';
+ * import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
+ * import { SchemaService } from '@warp-drive/core/reactive';
  *
  * class AppStore extends Store {
  *   createSchemaService() {
@@ -454,6 +472,15 @@ class DelegatingSchemaService {
     }
     return this._secondary.fields(resource);
   }
+  cacheFields(resource) {
+    if (this._preferred.hasResource?.(resource)) {
+      // @ts-expect-error
+      return this._preferred.cacheFields?.(resource);
+    }
+
+    // @ts-expect-error
+    return this._secondary.cacheFields?.(resource);
+  }
   transformation(field) {
     return this._preferred.transformation(field);
   }
@@ -484,6 +511,9 @@ class DelegatingSchemaService {
   registerHashFn(hashFn) {
     this._preferred.registerHashFn(hashFn);
   }
+  CAUTION_MEGA_DANGER_ZONE_hasExtension(ext) {
+    return this._preferred.CAUTION_MEGA_DANGER_ZONE_hasExtension(ext);
+  }
   CAUTION_MEGA_DANGER_ZONE_registerExtension(extension) {
     this._preferred.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
   }

package/dist/model-for-CqXsIKws.js

@@ -0,0 +1,221 @@
+import { tracked, cached } from '@glimmer/tracking';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { a as decorateFieldV2, i as initializeDeferredDecorator, d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
+class Fragment {
+  static {
+    decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  static {
+    decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  get hasDirtyAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  get isFragment() {
+    return true;
+  }
+  get $type() {
+    const {
+      field
+    } = this[Context];
+    return field?.type;
+  }
+  rollbackAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    if (path) {
+      const oldValue = store.cache.getRemoteAttr(resourceKey, path);
+      store.cache.setAttr(resourceKey, path, oldValue);
+    }
+  }
+}
+const FragmentExtension = {
+  kind: 'object',
+  name: 'fragment',
+  features: Fragment
+};
+class FragmentArray {
+  static {
+    decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  static {
+    decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  get hasDirtyAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  addFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    return this.addObject(fragment);
+  }
+  createFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    return this.pushObject(fragment);
+  }
+  removeFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    const index = this.indexOf(fragment);
+    if (index !== -1) {
+      this.splice(index, 1);
+    }
+  }
+  rollbackAttributes() {
+    for (const fragment of this) {
+      // @ts-expect-error TODO: fix these types
+      fragment?.rollbackAttributes?.();
+    }
+  }
+}
+const FragmentArrayExtension = {
+  kind: 'array',
+  name: 'fragment-array',
+  features: FragmentArray
+};
+
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap();
+function getShimClass(store, modelName) {
+  let shims = AvailableShims.get(store);
+  if (!shims) {
+    shims = Object.create(null);
+    AvailableShims.set(store, shims);
+  }
+  let shim = shims[modelName];
+  if (shim === undefined) {
+    shim = shims[modelName] = new ShimModelClass(store, modelName);
+  }
+  return shim;
+}
+const AttributeKinds = ['field', 'attribute', 'object', 'array', 'schema-object', 'schema-array'];
+
+// Mimics the static apis of @warp-drive/legacy/model
+class ShimModelClass {
+  constructor(store, modelName) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
+  get fields() {
+    const fields = new Map();
+    const fieldSchemas = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fieldSchemas.forEach((schema, key) => {
+      // @ts-expect-error checking if a string is a valid string
+      if (AttributeKinds.includes(schema.kind)) {
+        fields.set(key, 'attribute');
+      } else if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        fields.set(key, schema.kind);
+      }
+    });
+    return fields;
+  }
+  get attributes() {
+    const attrs = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        attrs.set(key, schema);
+        // @ts-expect-error checking if a string is a valid string
+      } else if (AttributeKinds.includes(schema.kind)) {
+        attrs.set(key, {
+          kind: 'attribute',
+          name: key,
+          type: null,
+          options: schema.options ?? {}
+        });
+      }
+    });
+    return attrs;
+  }
+  get relationshipsByName() {
+    const rels = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        rels.set(key, schema);
+      }
+    });
+    return rels;
+  }
+  eachAttribute(callback, binding) {
+    this.attributes.forEach((schema, key) => {
+      callback.call(binding, key, schema);
+    });
+  }
+  eachRelationship(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        callback.call(binding, key, schema);
+      }
+    });
+  }
+  eachTransformedAttribute(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        const type = schema.type;
+        if (type) callback.call(binding, key, type);
+      }
+    });
+  }
+}
+function fragmentsModelFor(modelName) {
+  return getShimClass(this, modelName);
+}
+const modelFor = fragmentsModelFor;
+export { FragmentExtension as F, FragmentArrayExtension as a, FragmentArray as b, Fragment as c, fragmentsModelFor as f, modelFor as m };

package/dist/model-fragments.js

@@ -0,0 +1,76 @@
+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";
+
+/**
+ * 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 };