ngx-t-forms-types 0.0.34 → 0.0.35

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.34",
+  "version": "0.0.35",
   "description": "Typings and interfaces for the ngx-t-forms library for dynamic forms.",
   "keywords": [
     "typings",