ngx-t-forms-types 0.0.33 → 0.0.35

package/dist/interfaces/Import/ImportIdentity.d.ts

@@ -0,0 +1,32 @@
+/**
+ * How an import session decides that two rows are the same record.
+ *
+ * Passed to the import controller's `runImport` / `runMultipleInputImport`
+ * as per-import data — which fields identify a record in *this* form — not
+ * as application configuration. Only rows of the one session are compared;
+ * records already persisted are the server's to check.
+ *
+ * @public
+ */
+export interface ImportIdentity {
+    /**
+     * `formControlName`s that together identify a record (for a multiple-input
+     * import: the child inputs' `formControlName`s). A row whose values for all
+     * of them repeat an earlier row's is a duplicate of that row. Empty or
+     * absent disables duplicate detection. A name the form does not have
+     * rejects the run rather than matching nothing.
+     */
+    readonly distinctKeys: readonly string[];
+    /**
+     * What to do with a duplicate.
+     *
+     * - `skip` — the row is never processed: no tower, no fetches. It is
+     *   reported with status `duplicate` and `duplicateOf` naming the row it
+     *   repeats. The default.
+     * - `flag` — the row is processed and validated like any other and keeps
+     *   its real status; only `duplicateOf` marks it. For hosts that want to
+     *   show what the duplicate contained. Such a row still must not be
+     *   imported.
+     */
+    readonly onDuplicate?: 'skip' | 'flag';
+}

package/dist/interfaces/Import/ImportIdentity.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/Import/ImportProgress.d.ts

@@ -14,7 +14,11 @@ export interface ImportProgress {
     pending: number;
     /** Rows currently processing. */
     processing: number;
-    /** `valid` + `overridable` + `invalid` — i.e. rows that fully settled (regardless of validity). */
+    /**
+     * `valid` + `overridable` + `invalid` + rows held with status `duplicate` —
+     * i.e. rows that reached an outcome. `complete + error === total` once a
+     * run has finished, duplicates included.
+     */
     complete: number;
     /** Rows that settled with no errors. */
     valid: number;
@@ -24,6 +28,13 @@ export interface ImportProgress {
     invalid: number;
     /** Rows that threw before settling. */
     error: number;
+    /**
+     * Rows recognised as repeating an earlier row (`duplicateOf` set). Under
+     * the default `skip` policy these carry status `duplicate` and are counted
+     * in `complete`; under `flag` they keep their real status and are counted
+     * there as well.
+     */
+    duplicate: number;
     /** Underlying array — useful for rendering per-row UI. */
     rows: ImportRowState[];
 }

package/dist/interfaces/Import/ImportRowState.d.ts

@@ -13,12 +13,19 @@
  *   pre-process error (a row carrying both blocking and overridable errors is
  *   `invalid`, not `overridable`).
  * - `error`       — `_processRow` threw before settle (tower init failure, etc.).
+ * - `duplicate`   — the row repeats an earlier row of the session on the
+ *   fields the import was given as its identity (`ImportIdentity`), and is
+ *   held out of the import; {@link ImportRowState.duplicateOf} names the row
+ *   it repeats. A row skipped before its tower was built has no other
+ *   verdict; one recognised only after it settled keeps its settled value
+ *   and errors under this status. Under `onDuplicate: 'flag'` a duplicate
+ *   keeps its real status instead and only `duplicateOf` marks it.
  *
  * Upstreamed from `ngx-t-forms` per DECISIONS.md D-016.
  *
  * @public
  */
-export type ImportRowStatus = 'pending' | 'processing' | 'valid' | 'overridable' | 'invalid' | 'error';
+export type ImportRowStatus = 'pending' | 'processing' | 'valid' | 'overridable' | 'invalid' | 'error' | 'duplicate';
 /**
  * Per-row state recorded throughout an import session.
  *
@@ -63,4 +70,48 @@ export interface ImportRowState {
     colErrors?: Record<string, string>;
     /** Free-form message attached when `status === 'error'`. */
     errorMessage?: string;
+    /**
+     * formControlName → the cells of a choice field (select, autocomplete,
+     * paginated selection table) whose text matched MORE THAN ONE of the
+     * field's options, with the options it could be. The import accepts an
+     * option's visible label (or, for a table, any of its column values) in
+     * place of its stored value; a unique match is substituted silently, a
+     * tie is reported here so the user can pick, and the row stays `invalid`
+     * (`colErrors` carries `ambiguousOption:<text>`) until each is settled.
+     * A multi-select cell lists one entry per unsettled value.
+     */
+    optionChoices?: Record<string, ImportOptionChoice[]>;
+    /**
+     * The `rowIndex` of the earlier row this row repeats, when the session was
+     * given an `ImportIdentity` and this row's identity matches. Always the
+     * LOWEST index of the matching group — first wins — so the relation is
+     * stable and a host can offer "go to row N". Set under both duplicate
+     * policies; under `skip` the row's `status` is `duplicate` as well. Cleared
+     * when a re-run changes the identities so that the row no longer repeats
+     * anything.
+     */
+    duplicateOf?: number;
+}
+/**
+ * One option an imported cell could stand for.
+ *
+ * @public
+ */
+export interface ImportOptionCandidate {
+    /** The value the form stores when this option is chosen. */
+    value: unknown;
+    /** What the form shows for the option — its label, or a table row's column values. */
+    label: string;
+}
+/**
+ * An imported cell (or one value of a multi-select cell) whose text matched
+ * several options of a choice field. See {@link ImportRowState.optionChoices}.
+ *
+ * @public
+ */
+export interface ImportOptionChoice {
+    /** The text as it was imported. */
+    text: string;
+    /** The options it matched, in the field's option order. */
+    candidates: ImportOptionCandidate[];
 }

package/dist/interfaces/Import/index.d.ts

@@ -1,2 +1,3 @@
-export { ImportRowState, ImportRowStatus } from './ImportRowState.js';
+export { ImportOptionCandidate, ImportOptionChoice, ImportRowState, ImportRowStatus } from './ImportRowState.js';
 export { ImportProgress } from './ImportProgress.js';
+export { ImportIdentity } from './ImportIdentity.js';

package/dist/interfaces/formInput/IMscoaAccount.d.ts

@@ -1,5 +1,6 @@
 import { MscoaValuetValidationErrors } from "../environment/IStoreFunctions.js";
 import { IBasicFormInput } from "./BasicFormInputInterface.js";
+import { MinInputMapInput } from "./MinimumInputRequiredInterface.js";
 import { ScoaInnerInput } from "./MscoaInput.js";
 export interface IVersion {
     versionNumber: number;
@@ -120,6 +121,34 @@ export interface IIncludedSegmentConfig {
     additionalAccounts: string[];
     segmentExtension: boolean;
     id: string;
+    /**
+     * Optional account-path limit for the picker: a colon-separated path into this
+     * segment's branch of the account tree, e.g.
+     * `Net Assets:Reserves and Funds:Revaluation Reserve`. When set, the account
+     * picker shows only that branch — its ancestors stay visible as context but
+     * cannot be selected — so only accounts at or beneath it can be chosen.
+     *
+     * Absent or empty means every branch of the segment is selectable, which is
+     * exactly how every segment saved before this member existed behaves. A path
+     * the loaded tree does not contain is ignored the same way, so a stale limit
+     * can never lock a segment out of every account.
+     */
+    limitToChildOfAccount?: string;
+    /**
+     * Optional dynamic source for {@link IIncludedSegmentConfig.limitToChildOfAccount}:
+     * another form input whose CURRENT value supplies the account path at the
+     * moment the picker opens. Shaped exactly like a required-input `mapTo`
+     * binding ({@link MinInputMapInput}); the runtime reads the input by `inputId`
+     * from the form the MSCOA field belongs to (an account-level custom input of
+     * the same MSCOA field is reachable too).
+     *
+     * The mapped value is honoured when it is a string — or an array of strings,
+     * one per level — naming a branch that exists in the segment tree. Otherwise
+     * the fixed `limitToChildOfAccount` applies when it resolves, and failing that
+     * every branch stays selectable. The mapping can therefore never lock the
+     * segment on its own, and an unfilled source input falls back gracefully.
+     */
+    limitToChildOfAccountMapTo?: MinInputMapInput;
 }
 /**
  * How the {@link IDualCashExclusionConfig.rules} combine into one verdict.
@@ -198,6 +227,18 @@ export interface IScoaInputConfig {
      * non-Dual accounting bases.
      */
     dualCashExclusion?: IDualCashExclusionConfig;
+    /**
+     * Opt-in: lets the user pick an account at ANY level of the tree, not only a
+     * posting-level one (`PostingLevel === 'Y'`, plus `BreakDownAllowed === 'Y'`
+     * on the PROJECT segment). Absent or `false` keeps the posting-level
+     * restriction every input had before this member existed.
+     *
+     * The restriction is enforced by the picker alone — nothing downstream
+     * re-validates posting level — so enabling it widens what a form can capture,
+     * and a consumer that posts the captured account to a ledger must be prepared
+     * for a group-level account.
+     */
+    allowNonPostingLevelAccount?: boolean;
 }
 export interface IGetTreeResponse {
     message: string;

package/dist/schemas/MscoaConfigSchema.d.ts

@@ -1,4 +1,10 @@
 import Joi from 'joi';
+/**
+ * Joi shape of the `MinInputMapInput` a segment may name as the dynamic source
+ * of its account-path limit. `inputId` is the only member the runtime reads;
+ * the other three are the descriptive half the builder stamps alongside it.
+ */
+export declare const AccountPathLimitSourceSchema: Joi.ObjectSchema<any>;
 export declare const IncludedSegmentConfigSchema: Joi.ObjectSchema<any>;
 export declare const DualCashExclusionRuleSchema: Joi.ObjectSchema<any>;
 export declare const DualCashExclusionConfigSchema: Joi.ObjectSchema<any>;

package/dist/schemas/MscoaConfigSchema.js

@@ -1,5 +1,16 @@
 import Joi from 'joi';
 import { AccountingBasis } from '../interfaces/formInput/IMscoaAccount.js';
+/**
+ * Joi shape of the `MinInputMapInput` a segment may name as the dynamic source
+ * of its account-path limit. `inputId` is the only member the runtime reads;
+ * the other three are the descriptive half the builder stamps alongside it.
+ */
+export const AccountPathLimitSourceSchema = Joi.object({
+    inputId: Joi.string().required(),
+    formControlName: Joi.string().allow('').optional(),
+    dataType: Joi.string().allow('').optional(),
+    element: Joi.string().allow('').optional()
+});
 export const IncludedSegmentConfigSchema = Joi.object({
     segment: Joi.string(),
     customSegment: Joi.string().optional(),
@@ -10,7 +21,9 @@ export const IncludedSegmentConfigSchema = Joi.object({
     inheritValueFromAccrual: Joi.boolean().optional(),
     vatSelectonActive: Joi.boolean().optional(),
     segmentExtension: Joi.boolean().required(),
-    id: Joi.string().required()
+    id: Joi.string().required(),
+    limitToChildOfAccount: Joi.string().allow('').optional(),
+    limitToChildOfAccountMapTo: AccountPathLimitSourceSchema.optional()
 });
 export const DualCashExclusionRuleSchema = Joi.object({
     id: Joi.string().optional(),
@@ -32,7 +45,8 @@ export const MscoaInputConfigSchema = Joi.object({
     accountingBasis: Joi.string().valid(...Object.values(AccountingBasis)).optional(),
     extensionAccountsForSegments: Joi.array().items(Joi.string()).optional(),
     showAllSegments: Joi.boolean().required(),
-    dualCashExclusion: DualCashExclusionConfigSchema.optional()
+    dualCashExclusion: DualCashExclusionConfigSchema.optional(),
+    allowNonPostingLevelAccount: Joi.boolean().optional()
 });
 export function validateMscoaInputConfig(value) {
     const { error, value: validatedValue } = MscoaInputConfigSchema.validate(value);

package/dist/skillet/input-members.d.ts

@@ -237,6 +237,7 @@ export declare const draftMemberSchemas: {
             inheritValueFromAccrual: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
             vatSelectonActive: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
             segmentExtension: s.BooleanType;
+            limitToChildOfAccount: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
         }>>;
         cashSegments: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
             segment: string;
@@ -248,9 +249,11 @@ export declare const draftMemberSchemas: {
             inheritValueFromAccrual: boolean | null;
             vatSelectonActive: boolean | null;
             segmentExtension: boolean;
+            limitToChildOfAccount: string | null;
         }[] | null>;
         accountValueLabel: s.EnumType<string[]>;
         showAllSegments: s.BooleanType;
+        allowNonPostingLevelAccount: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
         extensionAccountsForSegments: s.ArrayType<s.StringType>;
         dualCashExclusion: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
             rules: {

package/dist/skillet/members/mscoa.d.ts

@@ -58,6 +58,12 @@ import { AssertNever } from '../internal/coupling.js';
  * `string | undefined`. The builder's segment form declares it
  * `Validators.required`, so a row without one cannot be saved by hand either.
  * Narrower than the interface is the permitted direction; wider is not.
+ *
+ * `limitToChildOfAccountMapTo` — the run-time binding that reads a segment's
+ * account-path limit off another form input — is not offered, for the reason
+ * `inputs` is not: it cross-references an input by id, and ids are stamped by
+ * the builder after generation. The fixed `limitToChildOfAccount` path IS
+ * offered; the binding is authored in the builder's segment editor.
  */
 export interface MscoaSegmentDraft {
     segment: string;
@@ -69,6 +75,7 @@ export interface MscoaSegmentDraft {
     inheritValueFromAccrual: boolean | null;
     vatSelectonActive: boolean | null;
     segmentExtension: boolean;
+    limitToChildOfAccount: string | null;
 }
 export interface MscoaDualCashExclusionRuleDraft {
     pattern: string;
@@ -89,6 +96,7 @@ export interface MscoaConfigDraft {
     extensionAccountsForSegments: string[];
     showAllSegments: boolean;
     dualCashExclusion: MscoaDualCashExclusionDraft | null;
+    allowNonPostingLevelAccount: boolean | null;
 }
 /**
  * `DualCashExclusionMatchMode` is a string-union type with no runtime object to
@@ -130,6 +138,7 @@ export declare const mscoaConfigSchema: s.ObjectType<{
         inheritValueFromAccrual: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
         vatSelectonActive: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
         segmentExtension: s.BooleanType;
+        limitToChildOfAccount: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
     }>>;
     cashSegments: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
         segment: string;
@@ -141,9 +150,11 @@ export declare const mscoaConfigSchema: s.ObjectType<{
         inheritValueFromAccrual: boolean | null;
         vatSelectonActive: boolean | null;
         segmentExtension: boolean;
+        limitToChildOfAccount: string | null;
     }[] | null>;
     accountValueLabel: s.EnumType<string[]>;
     showAllSegments: s.BooleanType;
+    allowNonPostingLevelAccount: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
     extensionAccountsForSegments: s.ArrayType<s.StringType>;
     dualCashExclusion: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
         rules: {

package/dist/skillet/members/mscoa.js

@@ -57,6 +57,7 @@ const segmentSchema = s.object('One segment of the chart of accounts the user pi
     // form already persisted with it.
     vatSelectonActive: optional(s.boolean('Adds the VAT-status column to the account chart. It applies to the ITEM segment, which is the only one carrying a VAT treatment; leave null elsewhere.')),
     segmentExtension: s.boolean('True for an extra level authored under a segment rather than a segment of the published chart. An extension row is keyed by customSegment and may reuse a segment key another row already claims; an ordinary row may not.'),
+    limitToChildOfAccount: optional(s.string('Optional colon-separated path into this segment\'s branch of the chart, such as "Net Assets:Reserves and Funds:Revaluation Reserve". When set, the user can only pick accounts at or beneath that branch; the levels above it are shown for context but cannot be selected. Use it when the form captures one known category — a specific reserve, one asset class — and the account must not fall outside it. Leave null to offer the whole segment, which is the usual case. A path the chart does not contain is ignored and the whole segment is offered anyway, so guess nothing: name a branch only when the request states it.')),
 });
 /**
  * One cash-exclusion rule.
@@ -104,6 +105,7 @@ export const mscoaConfigSchema = s.object(describe('How this control asks the us
     cashSegments: optional(s.array('The segments captured on the cash side. Only meaningful when the accounting basis is cash or dual; leave null for an accrual-only input. A cash row that mirrors an accrual one should normally set inheritValueFromAccrual rather than ask the user twice.', segmentSchema)),
     accountValueLabel: s.enumeration(`Which field of the account identifies it to the user, everywhere this control shows one. Choose the field an administrator would read back in the chart of accounts. ${ACCOUNT_VALUE_LABEL_GLOSS}.`, ACCOUNT_VALUE_LABEL_ENTRIES),
     showAllSegments: s.boolean('True reflects every segment of the loaded account tree, read-only, instead of only the ones listed here — the application reconciles the list against the tree, so segments authored here are kept but not exclusive. False shows exactly the segments listed and nothing else, which is the usual choice.'),
+    allowNonPostingLevelAccount: optional(s.boolean('True lets the user pick an account at any level of the chart, not only a posting-level account. Leave null — posting-level accounts only, the default every existing input has — unless the request says a group account must be selectable, such as a budget captured at a summary line.')),
     extensionAccountsForSegments: s.array('Names of extra account columns this control offers on top of the ordinary account, each becoming a column on the chart. A segment opts into one by naming it in its own additionalAccounts. Leave empty when the control captures ordinary accounts only.', s.string('An extension-account name, such as a counter-account this form also captures.')),
     dualCashExclusion: optional(s.object('Dual basis only: when the cash side is NOT required, despite the basis asking for both. Leave null to require both sides always, which is the default behaviour and the right answer unless the form has a stated exception.', {
         rules: optional(s.array('The conditions tested against the accounts the user selected on the accrual side. A rule whose pattern does not compile never matches, so it can never suppress the cash side by accident.', dualCashExclusionRuleSchema)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-t-forms-types",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "Typings and interfaces for the ngx-t-forms library for dynamic forms.",
   "keywords": [
     "typings",