@kosdev-code/kos-nx-plugin 2.0.40 → 2.1.0

package/src/generators/kos-container-model/files/model/__nameDashCase__-registration.ts.template

@@ -1,113 +0,0 @@
-import {  <% if (singleton) { %>Singleton<% } %>KosModelRegistrationFactory } from "@kosdev-code/kos-ui-sdk";
-import type { <%= nameProperCase %>Options } from "./types";
-import { <%= modelNameProperCase %> } from "./<%= modelNameDashCase %>-registration";
-import { <%= nameProperCase %>ModelImpl, MODEL_TYPE } from "./<%= nameDashCase %>-model";
-import type { <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
-
-
-/**
- * # <%= nameProperCase %>
- *
- * The registration bean includes convenience methods for creating and working with <%= nameProperCase %>Model instances.
- *
- * ## type
- * The type property is a string that identifies the model type.
- * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
- * used when declaring dependencies on models.
- *
- * @example
- * ```typescript
- *
- * @kosDependency({modelType: <%= nameProperCase %>.type, id: "<%= nameCamelCase %>Id"})
- * private <%= nameCamelCase %>Model: <%= nameProperCase %>Model;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new <%= nameProperCase %>Model instances.
- *
- <% if (singleton) { %>
- * As this is a singleton model, the factory function accepts the model options as its argument.
- *
- * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = <%= nameProperCase %>.factory({
- *   // Add option data
- * });
- * ```
- <% } else { %>
- * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
- *
- * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = <%= nameProperCase %>.factory("<%= nameCamelCase %>Id")({
- *   // Add option data
- * });
- * ```
- <% } %>
-
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a <%= nameProperCase %>Model.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (<%= nameProperCase %>.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to <%= nameProperCase %>Model
- *    // and the compiler will know that the model has the <%= nameProperCase %>Model interface
- *    model.updateAvailability(false);
- * }
- * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { <%= nameProperCase %> } from "<%= importPath %>";
- * ...
- * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...<%= nameProperCase %>.registration,
- * };
- * ```
- *
- * ## registration.singleton
- <% if (singleton) { %>
- * The <%= nameCamelCase %> model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
- * If the model does not yet exist, it will be created passing in the provided options to initialize it.
- *
- * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
- <% } else { %>
- * The <%= nameCamelCase %> model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
- * If the factory function is called with an ID that already exists, the existing model will be returned.
- <% } %>
- * */
-export const <%= nameProperCase %> = new <% if (singleton) { %>Singleton<% } %>KosModelRegistrationFactory<
-  <%= nameProperCase %>Model,
-  <%= nameProperCase %>Options
->({
-  class: <%= nameProperCase %>ModelImpl,
-  type: MODEL_TYPE,
-});
-
-
-<%= nameProperCase %>.addRelatedModel(<%= modelNameProperCase %>);

package/src/generators/kos-model/files/model/__nameDashCase__-registration.ts.template

@@ -1,144 +0,0 @@
-<% const hasFutureSupport = futureAware && futureAware !== 'none'; %>
-<% const hasCompanionSupport = companion; %>
-<% const needsAnyCast = hasFutureSupport || hasCompanionSupport; %>
-import {  <% if (singleton) { %>Singleton<% } %>KosModelRegistrationFactory } from "<% if (internal) {%>../../../core/core/registration<% } else { %>@kosdev-code/kos-ui-sdk<% } %>";
-import type { <%= nameProperCase %>Options } from "./types";
-import { <%= nameProperCase %>ModelImpl, MODEL_TYPE, <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
-
-/**
- * # <%= nameProperCase %>
- *
- * The registration bean includes convenience methods for creating and working with <%= nameProperCase %>Model instances.
-<% if (hasFutureSupport) { %>
- * 
- * ## Future Support
- * This model includes <%= futureAware %> Future support for tracking long-running operations with:
- * - Progress tracking (0-1) with reactive updates  
- * - Status messages during operation
- * - Cancellation support with bi-directional AbortController integration
- * - Reactive integration for UI updates
-<% if (futureAware === 'complete') { %>
- * - Internal access to Future state for custom logic and computed properties
-<% } %>
-<% } %>
- *
- * ## type
- * The type property is a string that identifies the model type.
- * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
- * used when declaring dependencies on models.
- *
- * @example
- * ```typescript
- *
- * @kosDependency({modelType: <%= nameProperCase %>.type, id: "<%= nameCamelCase %>Id"})
- * private <%= nameCamelCase %>Model: <%= nameProperCase %>Model;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new <%= nameProperCase %>Model instances.
- *
- <% if (singleton) { %>
- * As this is a singleton model, the factory function accepts the model options as its argument.
- *
- * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = <%= nameProperCase %>.factory({
- *   // Add option data
- * });
-<% if (hasFutureSupport) { %>
- * 
- * // Example: Accessing Future state (when a Future is active)
- * const isRunning = model.futureIsRunning;
- * const progress = model.futureProgress;  // 0-1
- * const status = model.futureStatus;      // Current status message
-<% } %>
- * ```
- <% } else { %>
- * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
- *
- * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = <%= nameProperCase %>.factory("<%= nameCamelCase %>Id")({
- *   // Add option data
- * });
-<% if (hasFutureSupport) { %>
- * 
- * // Example: Accessing Future state (when a Future is active)
- * const isRunning = model.futureIsRunning;
- * const progress = model.futureProgress;  // 0-1
- * const status = model.futureStatus;      // Current status message
-<% } %>
- * ```
- <% } %>
-
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a <%= nameProperCase %>Model.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (<%= nameProperCase %>.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to <%= nameProperCase %>Model
- *    // and the compiler will know that the model has the <%= nameProperCase %>Model interface
- *    model.updateAvailability(false);
-<% if (hasFutureSupport) { %>
- *    
- *    // Future capabilities are also available
- *    const isRunning = model.futureIsRunning;
- *    const progress = model.futureProgress;
-<% } %>
- * }
- * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { <%= nameProperCase %> } from "@kos-ui/project-models";
- * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
- *
- * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
- *
- * KosModelRegistry.dispense
- * .models()
- * .model(<%= nameProperCase %>);
- * ```
- *
- * ## registration.singleton
- <% if (singleton) { %>
- * The <%= nameCamelCase %> model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
- * If the model does not yet exist, it will be created passing in the provided options to initialize it.
- *
- * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
- <% } else { %>
- * The <%= nameCamelCase %> model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
- * If the factory function is called with an ID that already exists, the existing model will be returned.
- <% } %>
- * */
-export const <%= nameProperCase %> = new <% if (singleton) { %>Singleton<% } %>KosModelRegistrationFactory<
-  <%= nameProperCase %>Model,
-  <%= nameProperCase %>Options
->({
-  class: <%= nameProperCase %>ModelImpl<% if (needsAnyCast) { %> as any<% } %>,  <% if (needsAnyCast) { %>// Type cast needed for<% if (hasFutureSupport && hasCompanionSupport) { %> Future and companion<% } else if (hasFutureSupport) { %> Future<% } else { %> companion<% } %> intersection<% } %>
-  type: MODEL_TYPE,
-});