@ng-atomic/components 16.2.0 → 16.3.1

package/esm2022/organisms/stripe-input-section/stripe-input-section.organism.mjs

@@ -0,0 +1,223 @@
+var StripeInputSectionOrganismStore_1;
+import { __decorate } from "tslib";
+import { ChangeDetectionStrategy, Component, Directive, Injectable, computed, effect, inject, input, viewChild } from '@angular/core';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { FormBuilder, Validators } from '@angular/forms';
+import { makeConfig } from '@ng-atomic/common/services/ui';
+import { LoadingBoxMoleculeStore } from '@ng-atomic/components/molecules/loading-box';
+import { InjectableComponent, NgAtomicComponent, TokenizedType, _computed } from '@ng-atomic/core';
+import { StripeAddressComponent, StripeCardComponent, StripeElementsDirective, StripeLinkAuthenticationComponent, StripePaymentElementComponent, injectStripe } from 'ngx-stripe';
+import { computedAsync } from 'ngxtension/computed-async';
+import { map, of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class StripeFormService {
+    constructor() {
+        this.fb = inject(FormBuilder);
+    }
+    build() {
+        return this.fb.group({
+            email: ['', [Validators.required, Validators.email]],
+            address: this.fb.group({
+                city: ['', []],
+                country: ['', [Validators.required]],
+                line1: ['', [Validators.required]],
+                line2: ['', []],
+                postalCode: ['', [Validators.required]],
+                state: ['', [Validators.required]],
+            }),
+            name: ['', [Validators.required]],
+            paymentMethodType: ['', [Validators.required]],
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeFormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeFormService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeFormService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+let StripeInputSectionOrganismStore = class StripeInputSectionOrganismStore extends InjectableComponent {
+    constructor() {
+        super(...arguments);
+        this.config = StripeInputSectionOrganismStore_1.Config.inject();
+        this.form = input(_computed(() => this.config().form));
+        this.clientSecret = input(_computed(() => this.config()?.clientSecret));
+        this.ephemeralKey = input();
+        this.appearance = input(_computed(() => this.config().appearance));
+        this.linkOptions = input(_computed(() => this.config().linkOptions));
+        this.addressOptions = input(_computed(() => this.config().addressOptions));
+        this.paymentOptions = input(_computed(() => this.config().paymentOptions));
+        this.elementsOptions = input(_computed(() => this.config().elementsOptions));
+        this._elementsOptions = computed(() => ({
+            ...this.elementsOptions(),
+            clientSecret: this.clientSecret(),
+        }));
+    }
+    static { StripeInputSectionOrganismStore_1 = this; }
+    static { this.Config = makeConfig(() => {
+        return () => ({
+            form: inject(StripeFormService).build(),
+            clientSecret: null,
+            appearance: {
+                theme: 'stripe',
+                labels: 'above',
+                variables: {
+                    colorPrimary: 'var(--accent-color)',
+                },
+            },
+            linkOptions: {
+                defaultValues: {
+                    email: ''
+                },
+            },
+            addressOptions: {
+                mode: 'shipping',
+                defaultValues: {}
+            },
+            paymentOptions: {
+                defaultValues: {
+                    billingDetails: {},
+                },
+                terms: {
+                    card: 'always',
+                    applePay: 'never',
+                },
+            },
+            elementsOptions: {
+                locale: 'ja',
+                language: 'ja',
+                appearance: {
+                    theme: 'stripe',
+                    labels: 'above',
+                    variables: {
+                        colorPrimary: '#404040',
+                    },
+                },
+                loader: 'always',
+            },
+        });
+    }, ['components', 'organisms', 'organisms-stripe-input-section']); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeInputSectionOrganismStore, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "17.2.2", type: StripeInputSectionOrganismStore, isStandalone: true, selector: "organisms-stripe-input-section", inputs: { form: { classPropertyName: "form", publicName: "form", isSignal: true, isRequired: false, transformFunction: null }, clientSecret: { classPropertyName: "clientSecret", publicName: "clientSecret", isSignal: true, isRequired: false, transformFunction: null }, ephemeralKey: { classPropertyName: "ephemeralKey", publicName: "ephemeralKey", isSignal: true, isRequired: false, transformFunction: null }, appearance: { classPropertyName: "appearance", publicName: "appearance", isSignal: true, isRequired: false, transformFunction: null }, linkOptions: { classPropertyName: "linkOptions", publicName: "linkOptions", isSignal: true, isRequired: false, transformFunction: null }, addressOptions: { classPropertyName: "addressOptions", publicName: "addressOptions", isSignal: true, isRequired: false, transformFunction: null }, paymentOptions: { classPropertyName: "paymentOptions", publicName: "paymentOptions", isSignal: true, isRequired: false, transformFunction: null }, elementsOptions: { classPropertyName: "elementsOptions", publicName: "elementsOptions", isSignal: true, isRequired: false, transformFunction: null } }, usesInheritance: true, ngImport: i0 }); }
+};
+StripeInputSectionOrganismStore = StripeInputSectionOrganismStore_1 = __decorate([
+    TokenizedType()
+], StripeInputSectionOrganismStore);
+export { StripeInputSectionOrganismStore };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeInputSectionOrganismStore, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'organisms-stripe-input-section' }]
+        }] });
+export class StripeInputSectionOrganism extends NgAtomicComponent {
+    constructor() {
+        super();
+        this.store = inject(StripeInputSectionOrganismStore);
+        this.stripe = injectStripe();
+        this.linkAuthElement = viewChild(StripeLinkAuthenticationComponent);
+        this.paymentElement = viewChild(StripePaymentElementComponent);
+        this.addressElement = viewChild(StripeAddressComponent);
+        this.paymentElementLoaded = computedAsync(() => {
+            if (this.paymentElement()) {
+                return this.paymentElement()?.load.pipe(map(() => true));
+            }
+            return of(false);
+        });
+        this.paymentElementLoaded$ = toObservable(this.paymentElementLoaded);
+        effect(() => {
+            this.store.form().setAsyncValidators(() => {
+                return this.paymentElementLoaded$.pipe(map((loaded) => loaded ? null : { stripeLoaded: true }));
+            });
+        });
+        // effect(() => {
+        //   this.linkAuthElement().
+        // })
+    }
+    onLoad(event) {
+        // console.debug('onLoad:', event.);
+    }
+    onChangeAuthentication(event) {
+        console.debug('onChangeAuthentication', event);
+        this.store.form().patchValue({ email: event.value.email });
+    }
+    onChangeAddress(event) {
+        this.store.form().patchValue({
+            address: {
+                ...event.value.address,
+                postalCode: event.value.address.postal_code,
+            },
+            name: event.value.name
+        });
+    }
+    onChangePayment(event) {
+        this.store.form().patchValue({ paymentMethodType: event.value.type });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeInputSectionOrganism, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.2.2", type: StripeInputSectionOrganism, isStandalone: true, selector: "organisms-stripe-input-section", viewQueries: [{ propertyName: "linkAuthElement", first: true, predicate: StripeLinkAuthenticationComponent, descendants: true, isSignal: true }, { propertyName: "paymentElement", first: true, predicate: StripePaymentElementComponent, descendants: true, isSignal: true }, { propertyName: "addressElement", first: true, predicate: StripeAddressComponent, descendants: true, isSignal: true }], usesInheritance: true, hostDirectives: [{ directive: StripeInputSectionOrganismStore, inputs: ["form", "form", "clientSecret", "clientSecret", "ephemeralKey", "ephemeralKey", "appearance", "appearance", "linkOptions", "linkOptions", "addressOptions", "addressOptions", "paymentOptions", "paymentOptions", "elementsOptions", "elementsOptions"] }], ngImport: i0, template: `
+  @if (store._elementsOptions()?.clientSecret) {
+    <ngx-stripe-elements
+      [stripe]="stripe"
+      [elementsOptions]="store._elementsOptions()"
+    >
+      <ngx-stripe-link-authentication
+        [options]="store.linkOptions()"
+        (change)="onChangeAuthentication($event)"
+        (load)="onLoad($event)"
+      />
+      <ngx-stripe-address
+        [options]="store.addressOptions()"
+        (change)="onChangeAddress($event)"
+      />
+      <ngx-stripe-payment
+        [appearance]="store.appearance()"
+        [elementsOptions]="store.elementsOptions()"
+        [options]="store.paymentOptions()"
+        (change)="onChangePayment($event)"
+      />
+    </ngx-stripe-elements>
+  } @else { <molecules-loading-box [loadingMessage]="'支払いフォームを初期化中'" injectable/> }
+  `, isInline: true, styles: [":host{display:block}:host{width:100%;padding:0 16px;box-sizing:border-box}:host ngx-stripe-elements{display:block;width:100%}\n"], dependencies: [{ kind: "directive", type: StripeElementsDirective, selector: "ngx-stripe-elements,[ngxStripeElements]", inputs: ["elementsOptions", "stripe"], outputs: ["elements"] }, { kind: "component", type: StripePaymentElementComponent, selector: "ngx-stripe-payment", inputs: ["containerClass", "options", "elementsOptions", "stripe", "appearance", "clientSecret", "doNotCreateUntilClientSecretIsSet"], outputs: ["load", "blur", "change", "focus", "ready", "escape", "loaderror"] }, { kind: "component", type: StripeLinkAuthenticationComponent, selector: "ngx-stripe-link-authentication", inputs: ["containerClass", "options", "elementsOptions", "stripe"], outputs: ["load", "blur", "change", "focus", "ready", "escape", "loaderror", "loaderstart"] }, { kind: "component", type: StripeAddressComponent, selector: "ngx-stripe-address", inputs: ["containerClass", "options", "elementsOptions", "stripe"], outputs: ["load", "blur", "change", "focus", "ready", "escape", "loaderror", "loaderstart"] }, { kind: "directive", type: LoadingBoxMoleculeStore, selector: "molecules-loading-box", inputs: ["loadingMessage"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: StripeInputSectionOrganism, decorators: [{
+            type: Component,
+            args: [{ selector: 'organisms-stripe-input-section', standalone: true, imports: [
+                        StripeElementsDirective,
+                        StripeCardComponent,
+                        StripePaymentElementComponent,
+                        StripeLinkAuthenticationComponent,
+                        StripeAddressComponent,
+                        LoadingBoxMoleculeStore,
+                    ], template: `
+  @if (store._elementsOptions()?.clientSecret) {
+    <ngx-stripe-elements
+      [stripe]="stripe"
+      [elementsOptions]="store._elementsOptions()"
+    >
+      <ngx-stripe-link-authentication
+        [options]="store.linkOptions()"
+        (change)="onChangeAuthentication($event)"
+        (load)="onLoad($event)"
+      />
+      <ngx-stripe-address
+        [options]="store.addressOptions()"
+        (change)="onChangeAddress($event)"
+      />
+      <ngx-stripe-payment
+        [appearance]="store.appearance()"
+        [elementsOptions]="store.elementsOptions()"
+        [options]="store.paymentOptions()"
+        (change)="onChangePayment($event)"
+      />
+    </ngx-stripe-elements>
+  } @else { <molecules-loading-box [loadingMessage]="'支払いフォームを初期化中'" injectable/> }
+  `, changeDetection: ChangeDetectionStrategy.OnPush, hostDirectives: [
+                        {
+                            directive: StripeInputSectionOrganismStore,
+                            inputs: [
+                                'form',
+                                'clientSecret', 'ephemeralKey', 'appearance',
+                                'linkOptions', 'addressOptions', 'paymentOptions', 'elementsOptions'
+                            ],
+                        },
+                    ], styles: [":host{display:block}:host{width:100%;padding:0 16px;box-sizing:border-box}:host ngx-stripe-elements{display:block;width:100%}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stripe-input-section.organism.js","sourceRoot":"","sources":["../../../../../../../packages/@ng-atomic/components/src/lib/organisms/stripe-input-section/stripe-input-section.organism.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Directive, Injectable, computed, effect, inject, input, viewChild } from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { FormBuilder, Validators } from '@angular/forms';\nimport { makeConfig } from '@ng-atomic/common/services/ui';\nimport { LoadingBoxMoleculeStore } from '@ng-atomic/components/molecules/loading-box';\nimport { InjectableComponent, NgAtomicComponent, TokenizedType, _computed } from '@ng-atomic/core';\nimport { Appearance, StripeAddressElementChangeEvent, StripeAddressElementOptions, StripeElementsOptions, StripeLinkAuthenticationElement, StripeLinkAuthenticationElementChangeEvent, StripeLinkAuthenticationElementOptions, StripePaymentElementChangeEvent, StripePaymentElementOptions } from '@stripe/stripe-js';\nimport { StripeAddressComponent, StripeCardComponent, StripeElementsDirective, StripeLinkAuthenticationComponent, StripePaymentElementComponent, injectStripe } from 'ngx-stripe';\nimport { computedAsync } from 'ngxtension/computed-async';\nimport { map, of } from 'rxjs';\n\n@Injectable({providedIn: 'root'})\nexport class StripeFormService {\n  readonly fb = inject(FormBuilder);\n\n  build() {\n    return this.fb.group({\n      email: ['', [Validators.required, Validators.email]],\n      address: this.fb.group({\n        city: ['', []], // MEMO(@nontangent): 住所のオートコンプリートによってはここが入力されないので必須を外している。\n        country: ['', [Validators.required]],\n        line1: ['', [Validators.required]],\n        line2: ['', []],\n        postalCode: ['', [Validators.required]],\n        state: ['', [Validators.required]],\n      }),\n      name: ['', [Validators.required]],\n      paymentMethodType: ['', [Validators.required]],\n    });\n  }\n}\n\n@TokenizedType()\n@Directive({standalone: true, selector: 'organisms-stripe-input-section'})\nexport class StripeInputSectionOrganismStore extends InjectableComponent {\n  static readonly Config = makeConfig(() => {\n    return () => ({\n      form: inject(StripeFormService).build(),\n      clientSecret: null as string | null,\n      appearance: {\n        theme: 'stripe',\n        labels: 'above',\n        variables: {\n          colorPrimary: 'var(--accent-color)',\n        },\n      } as Appearance,\n      linkOptions: {\n        defaultValues: {\n          email: ''\n        },\n      } as StripeLinkAuthenticationElementOptions,\n      addressOptions: {\n        mode: 'shipping',\n        defaultValues: { }\n      } as StripeAddressElementOptions,\n      paymentOptions: {\n        defaultValues: {\n          billingDetails: {},\n        },\n        terms: {\n          card: 'always',\n          applePay: 'never',\n        },\n      } as StripePaymentElementOptions,\n      elementsOptions: {\n        locale: 'ja',\n        language: 'ja',\n        appearance: {\n          theme: 'stripe',\n          labels: 'above',\n          variables: {\n            colorPrimary: '#404040',\n          },\n        },\n        loader: 'always',\n      } as StripeElementsOptions,\n    })\n  }, ['components', 'organisms', 'organisms-stripe-input-section']);\n  readonly config = StripeInputSectionOrganismStore.Config.inject();\n  readonly form = input(_computed(() => this.config().form));\n  readonly clientSecret = input(_computed(() => this.config()?.clientSecret));\n  readonly ephemeralKey = input<{ ephemeralKey: { associated_objects: {id: string}[], secret: string} }>();\n  readonly appearance = input(_computed(() => this.config().appearance));\n  readonly linkOptions = input(_computed(() => this.config().linkOptions));\n  readonly addressOptions = input(_computed(() => this.config().addressOptions));\n  readonly paymentOptions = input(_computed(() => this.config().paymentOptions));\n  readonly elementsOptions = input(_computed(() => this.config().elementsOptions));\n  readonly _elementsOptions = computed(() => ({\n    ...this.elementsOptions(),\n    clientSecret: this.clientSecret(),\n  }));\n}\n\n@Component({\n  selector: 'organisms-stripe-input-section',\n  standalone: true,\n  imports: [\n    StripeElementsDirective,\n    StripeCardComponent,\n    StripePaymentElementComponent,\n    StripeLinkAuthenticationComponent,\n    StripeAddressComponent,\n    LoadingBoxMoleculeStore,\n  ],\n  template: `\n  @if (store._elementsOptions()?.clientSecret) {\n    <ngx-stripe-elements\n      [stripe]=\"stripe\"\n      [elementsOptions]=\"store._elementsOptions()\"\n    >\n      <ngx-stripe-link-authentication\n        [options]=\"store.linkOptions()\"\n        (change)=\"onChangeAuthentication($event)\"\n        (load)=\"onLoad($event)\"\n      />\n      <ngx-stripe-address\n        [options]=\"store.addressOptions()\"\n        (change)=\"onChangeAddress($event)\"\n      />\n      <ngx-stripe-payment\n        [appearance]=\"store.appearance()\"\n        [elementsOptions]=\"store.elementsOptions()\"\n        [options]=\"store.paymentOptions()\"\n        (change)=\"onChangePayment($event)\"\n      />\n    </ngx-stripe-elements>\n  } @else { <molecules-loading-box [loadingMessage]=\"'支払いフォームを初期化中'\" injectable/> }\n  `,\n  styleUrl: './stripe-input-section.organism.scss',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  hostDirectives: [\n    {\n      directive: StripeInputSectionOrganismStore,\n      inputs: [\n        'form',\n        'clientSecret', 'ephemeralKey', 'appearance',\n        'linkOptions', 'addressOptions', 'paymentOptions', 'elementsOptions'\n      ],\n    },\n  ],\n})\nexport class StripeInputSectionOrganism extends NgAtomicComponent {\n  protected readonly store = inject(StripeInputSectionOrganismStore);\n  readonly stripe = injectStripe();\n  readonly linkAuthElement = viewChild(StripeLinkAuthenticationComponent);\n  readonly paymentElement = viewChild(StripePaymentElementComponent);\n  readonly addressElement = viewChild(StripeAddressComponent);\n\n  readonly paymentElementLoaded = computedAsync(() => {\n    if (this.paymentElement()) {\n      return this.paymentElement()?.load.pipe(map(() => true));\n    }\n    return of(false);\n  });\n  readonly paymentElementLoaded$ = toObservable(this.paymentElementLoaded);\n\n  constructor() {\n    super();\n    effect(() => {\n      this.store.form().setAsyncValidators(() => {\n        return this.paymentElementLoaded$.pipe(map((loaded) => loaded ? null : {stripeLoaded: true}));\n      });\n    });\n\n    // effect(() => {\n    //   this.linkAuthElement().\n    // })\n  }\n\n  protected onLoad(event: StripeLinkAuthenticationElement) {\n    // console.debug('onLoad:', event.);\n  }\n  \n  protected onChangeAuthentication(event: StripeLinkAuthenticationElementChangeEvent) {\n    console.debug('onChangeAuthentication', event);\n    this.store.form().patchValue({email: event.value.email});\n  }\n\n  protected onChangeAddress(event: StripeAddressElementChangeEvent) {\n    this.store.form().patchValue({\n      address: {\n        ...event.value.address,\n        postalCode: event.value.address.postal_code,\n      },\n      name: event.value.name\n    });\n  }\n\n  protected onChangePayment(event: StripePaymentElementChangeEvent) {\n    this.store.form().patchValue({paymentMethodType: event.value.type});\n  }\n}\n"]}

package/esm2022/organisms/table/index.helpers.mjs

@@ -0,0 +1,110 @@
+import { Injectable, inject } from "@angular/core";
+import { FormBuilder } from "@angular/forms";
+import { PaginationService } from "@ng-atomic/common/services/form/pagination";
+import { SortService } from "@ng-atomic/common/services/form/sort";
+import { wrapActions } from "@ng-atomic/core";
+import { injectProps } from "@ng-atomic/common/pipes/domain";
+import { omitBy } from "lodash-es";
+import * as i0 from "@angular/core";
+export function buildColumns(columns) {
+    return columns.map(column => {
+        if (typeof column === 'string') {
+            if (column === '__actions') {
+                return {
+                    type: 'actions',
+                    name: 'actions',
+                    visible: true,
+                    width: 80,
+                };
+            }
+            if (column === '__checkbox') {
+                return {
+                    type: 'checkbox',
+                    name: 'checkbox',
+                    visible: true,
+                    width: 80,
+                };
+            }
+            else {
+                return {
+                    type: 'text',
+                    name: column,
+                    visible: true,
+                    width: 80,
+                };
+            }
+        }
+        else {
+            return {
+                type: 'actions',
+                name: 'actions',
+                visible: true,
+                width: 80,
+                actions: wrapActions(column),
+            };
+        }
+    });
+}
+export class IndexTemplateFormBuilder {
+    constructor() {
+        this.sort = inject(SortService);
+        this.pagination = inject(PaginationService);
+        this.fb = inject(FormBuilder);
+    }
+    static { this.buildColumns = buildColumns; }
+    build({ query = undefined, sort = {}, page = {}, columns = [], } = {}) {
+        const omit = (obj) => omitBy(obj, value => value === undefined);
+        return this.fb.group(omit({
+            query: typeof query !== 'undefined' ? this.fb.control(query) : undefined,
+            page: this.pagination.build(page),
+            sort: this.sort.build(sort),
+            columns: this.buildColumnsForm(columns),
+        }));
+    }
+    buildColumnsForm(columns) {
+        return this.fb.array(columns.map(column => {
+            switch (column.type) {
+                case 'text':
+                    return this.fb.group({
+                        type: this.fb.control({ value: 'text', disabled: true }),
+                        name: this.fb.control({ value: column.name, disabled: true }),
+                        visible: this.fb.control(column.visible),
+                        width: this.fb.control(80),
+                    });
+                case 'checkbox':
+                    return this.fb.group({
+                        type: this.fb.control({ value: 'checkbox', disabled: true }),
+                        name: this.fb.control({ value: 'checkbox', disabled: true }),
+                        visible: this.fb.control(column.visible),
+                        width: this.fb.control(80),
+                    });
+                case 'actions':
+                    return this.fb.group({
+                        type: this.fb.control({ value: 'actions', disabled: true }),
+                        name: this.fb.control({ value: 'actions', disabled: true }),
+                        visible: this.fb.control(column.visible),
+                        width: this.fb.control(80),
+                        actions: this.fb.control(column.actions),
+                    });
+                default:
+                    throw new Error(`Unknown column type: ${column.type}`);
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: IndexTemplateFormBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: IndexTemplateFormBuilder, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: IndexTemplateFormBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+export function injectIndexFormBuilder() {
+    return inject(IndexTemplateFormBuilder);
+}
+export function injectIndexForm({ columns = buildColumns(['__checkbox', ...injectProps()(), '__actions']), query = undefined, } = {}) {
+    return inject(IndexTemplateFormBuilder).build({
+        columns,
+        query,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.helpers.js","sourceRoot":"","sources":["../../../../../../../packages/@ng-atomic/components/src/lib/organisms/table/index.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from \"@angular/core\";\nimport { FormArray, FormBuilder, FormControl, FormGroup, FormRecord } from \"@angular/forms\";\nimport { PaginationFormValue, PaginationService } from \"@ng-atomic/common/services/form/pagination\";\nimport { SortFormValue, SortService } from \"@ng-atomic/common/services/form/sort\";\nimport { Actions, wrapActions } from \"@ng-atomic/core\";\nimport { Column } from \"@ng-atomic/common/models\";\nimport { injectProps } from \"@ng-atomic/common/pipes/domain\";\nimport { omitBy } from \"lodash-es\";\n\nexport type ActionsColumnForm = FormGroup<{\n  type: FormControl<'actions'>,\n  name: FormControl<string>,\n  visible: FormControl<boolean>,\n  width: FormControl<number>,\n  actions: FormControl<any>,\n}>;\n\nexport type CheckboxColumnForm = FormGroup<{\n  type: FormControl<'checkbox'>,\n  name: FormControl<string>,\n  visible: FormControl<boolean>,\n  width: FormControl<number>,\n}>;\n\nexport type TextColumnForm = FormGroup<{\n  type: FormControl<'text'>,\n  name: FormControl<string>,\n  visible: FormControl<boolean>,\n  width: FormControl<number>,\n}>;\n\nexport type ColumnsForm = FormArray<FormRecord<ActionsColumnForm | CheckboxColumnForm | TextColumnForm>>;\n\nexport function buildColumns(columns: (string | Actions)[]): Column[] {\n  return columns.map(column => {\n    if (typeof column === 'string') {\n      if (column === '__actions') {\n        return {\n          type: 'actions',\n          name: 'actions',\n          visible: true,\n          width: 80,\n        }\n      } if (column === '__checkbox') {\n        return {\n          type: 'checkbox',\n          name: 'checkbox',\n          visible: true,\n          width: 80,\n        }\n      } else {\n        return {\n          type: 'text',\n          name: column,\n          visible: true,\n          width: 80,\n        };\n      }      \n    } else {\n      return {\n        type: 'actions',\n        name: 'actions',\n        visible: true,\n        width: 80,\n        actions: wrapActions(column),\n      };\n    }\n  }); \n}\n\n\n\n@Injectable({ providedIn: 'root' })\nexport class IndexTemplateFormBuilder {\n  sort = inject(SortService);\n  pagination = inject(PaginationService)\n  fb = inject(FormBuilder);\n\n  static buildColumns = buildColumns;\n\n  build({\n    query = undefined,\n    sort = {},\n    page = {},\n    columns = [],\n  }: {\n    query?: string,\n    page?: Partial<PaginationFormValue>,\n    sort?: Partial<SortFormValue>,\n    columns?: Column[],\n  } = {}) {\n    const omit = <T extends object>(obj: T) => omitBy(obj, value => value === undefined) as T;\n    return this.fb.group(omit({\n      query: typeof query !== 'undefined' ? this.fb.control(query) : undefined,\n      page: this.pagination.build(page),\n      sort: this.sort.build(sort),\n      columns: this.buildColumnsForm(columns),\n    }));\n  }\n\n  buildColumnsForm(columns: Column[]) {\n    return this.fb.array(columns.map(column => {\n      switch (column.type) {\n        case 'text':\n          return this.fb.group({\n            type: this.fb.control({value: 'text' as const, disabled: true}),\n            name: this.fb.control({value: column.name, disabled: true}),\n            visible: this.fb.control(column.visible),\n            width: this.fb.control(80),\n          }) as TextColumnForm;\n        case 'checkbox':\n          return this.fb.group({\n            type: this.fb.control({value: 'checkbox' as const, disabled: true}),\n            name: this.fb.control({value: 'checkbox', disabled: true}),\n            visible: this.fb.control(column.visible),\n            width: this.fb.control(80),\n          }) as CheckboxColumnForm;\n        case 'actions':\n          return this.fb.group({\n            type: this.fb.control({value: 'actions' as const, disabled: true}),\n            name: this.fb.control({value: 'actions', disabled: true}),\n            visible: this.fb.control(column.visible),\n            width: this.fb.control(80),\n            actions: this.fb.control(column.actions),\n          }) as ActionsColumnForm;\n        default:\n          throw new Error(`Unknown column type: ${(column as any).type}`);\n      }\n    }));\n  }\n}\n\nexport function injectIndexFormBuilder() {\n  return inject(IndexTemplateFormBuilder);\n}\n\nexport function injectIndexForm({\n  columns = buildColumns(['__checkbox', ...injectProps()(), '__actions']),\n  query = undefined,\n}: {\n  columns?: Column[],\n  query?: string,\n} = {}) {\n  return inject(IndexTemplateFormBuilder).build({\n    columns,\n    query,\n  });\n}\n"]}

package/esm2022/organisms/table/index.mjs

@@ -0,0 +1,3 @@
+export * from './index.helpers';
+export * from './table.organism';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9AbmctYXRvbWljL2NvbXBvbmVudHMvc3JjL2xpYi9vcmdhbmlzbXMvdGFibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pbmRleC5oZWxwZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUub3JnYW5pc20nO1xuIl19

package/esm2022/organisms/table/ng-atomic-components-organisms-table.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctYXRvbWljLWNvbXBvbmVudHMtb3JnYW5pc21zLXRhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvQG5nLWF0b21pYy9jb21wb25lbnRzL3NyYy9saWIvb3JnYW5pc21zL3RhYmxlL25nLWF0b21pYy1jb21wb25lbnRzLW9yZ2FuaXNtcy10YWJsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==