@xxmachina/common 0.0.0-PLACEHOLDER

package/services/graphql/index.d.ts

@@ -0,0 +1,97 @@
+import * as _apollo_client from '@apollo/client';
+import * as graphql from 'graphql';
+import { DocumentNode } from 'graphql';
+import { GetHeaders, ApolloClientManagerService } from '@nx-ddd/hasura';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+import { FetchResult } from '@apollo/client/core';
+
+interface ExecutableGraphql {
+    endpoint: string;
+    query: string | DocumentNode;
+    variables: object;
+    headers: Record<string, string> | GetHeaders;
+}
+type ExecutableGetSchemaGraphql = Pick<ExecutableGraphql, 'endpoint' | 'headers'>;
+declare class GraphqlService {
+    readonly apolloClientManager: ApolloClientManagerService;
+    /**
+     * @TODO
+     * this.apolloMulti.getClientはendpoint単位でApolloClientを管理しているため、
+     * _query.graphql.headersに認証情報などが含まれていないリクエストが初めに来ると、
+     * {message: 'no subscriptions exist}のようなエラーが出る。
+     * Headersが更新されるたびに、ApolloClientを再生成するような処理も必要。
+     */
+    subscribe(graphql: ExecutableGraphql): Observable<graphql.FormattedExecutionResult<Record<string, any>, Record<string, any>>>;
+    query(graphql: ExecutableGraphql): Observable<_apollo_client.ApolloQueryResult<Record<string, any>>>;
+    getSchema(graphql: ExecutableGetSchemaGraphql): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphqlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphqlService>;
+}
+
+interface ExecutableGraphqlWithSplitting extends ExecutableGraphql {
+    enableSplitting?: boolean;
+}
+/**
+ * GraphqlServiceを拡張して、subscription分割機能を追加
+ *
+ * GraphQL/Hasuraの制限「1つのsubscriptionには1つのトップレベルフィールドのみ」を回避し、
+ * 複数のフィールドを含むsubscriptionを自動的に分割して並列実行します。
+ */
+declare class GraphqlEnhancedService extends GraphqlService {
+    private readonly splitter;
+    /**
+     * subscriptionクエリを実行
+     * デフォルトでsubscriptionは自動的に分割される
+     */
+    subscribe(graphql: ExecutableGraphqlWithSplitting): Observable<FetchResult<any>>;
+    /**
+     * subscriptionクエリを分割して並列実行し、結果を結合
+     */
+    private subscribeSplit;
+    /**
+     * クエリがsubscriptionかどうかを判定
+     */
+    private isSubscription;
+    /**
+     * クエリから使用されている変数を抽出
+     */
+    private extractUsedVariablesFromQuery;
+    /**
+     * 変数値から使用される変数のみをフィルタリング
+     */
+    private filterVariableValues;
+    /**
+     * GraphQLクエリから未使用の変数を削除
+     */
+    private removeUnusedVariables;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphqlEnhancedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphqlEnhancedService>;
+}
+
+/**
+ * GraphqlServiceをGraphqlEnhancedServiceで置き換えるプロバイダー
+ *
+ * 使用方法:
+ * ```typescript
+ * export default <Routes>[
+ *   {
+ *     path: '',
+ *     component: YourComponent,
+ *     providers: [
+ *       provideGraphqlEnhancedLocally()
+ *     ]
+ *   }
+ * ];
+ * ```
+ */
+declare function provideGraphqlEnhancedLocally(): Provider[];
+/**
+ * グローバルにGraphqlEnhancedServiceを提供
+ * app.config.tsで使用
+ */
+declare function provideGraphqlEnhancedGlobally(): Provider[];
+
+export { GraphqlEnhancedService, GraphqlService, provideGraphqlEnhancedGlobally, provideGraphqlEnhancedLocally };
+export type { ExecutableGetSchemaGraphql, ExecutableGraphql, ExecutableGraphqlWithSplitting };

package/services/query/config/index.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+
+type QueryConfig = Record<string, string>;
+declare const QUERY_CONFIG: InjectionToken<Observable<QueryConfig>>;
+declare function provideQueryConfig(useFactory: () => Observable<QueryConfig>): EnvironmentProviders;
+declare class QueryConfigService {
+    readonly config$: Observable<QueryConfig>;
+    protected replaceText(text: string, config: QueryConfig): string;
+    protected replace<T extends Record<string, any> | string>(params: T, config: QueryConfig): T;
+    resolve<T extends object>(params: T): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryConfigService>;
+}
+
+export { QUERY_CONFIG, QueryConfigService, provideQueryConfig };
+export type { QueryConfig };

package/services/query/index.d.ts

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { Query } from '@xxmachina/common/domain';
+import { ExecutableGraphql, GraphqlService } from '@xxmachina/common/services/graphql';
+import { QueryConfigService } from '@xxmachina/common/services/query/config';
+import * as i0 from '@angular/core';
+import { TransformerService } from '@xxmachina/common/services/transformer';
+
+interface ExecutableQuery {
+    graphql: ExecutableGraphql;
+}
+declare class QueryResolverService {
+    readonly config: QueryConfigService;
+    resolve(query: Query): Observable<ExecutableQuery>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryResolverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryResolverService>;
+}
+
+declare class QueryService {
+    protected readonly resolver: QueryResolverService;
+    protected readonly graphql: GraphqlService;
+    protected readonly transformer: TransformerService;
+    subscribe<R extends object = any>(query: Query): Observable<R>;
+    query<R extends object = any>(query: Query): Observable<R>;
+    getSchema(query: Query): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryService>;
+}
+
+export { QueryService };

package/services/speech/index.d.ts

@@ -0,0 +1,37 @@
+import * as rxjs from 'rxjs';
+import * as _angular_core from '@angular/core';
+
+declare class SpeechService {
+    private static instanceCounter;
+    private readonly PAUSE_THRESHOLD;
+    private recognition;
+    private lastSpeechTime;
+    private ignoreResults;
+    readonly transcript: _angular_core.WritableSignal<{
+        finalized: string;
+        interim: string;
+    }>;
+    readonly transcript$: rxjs.Observable<{
+        finalized: string;
+        interim: string;
+    }>;
+    readonly isListening: _angular_core.WritableSignal<boolean>;
+    readonly activeComponentId: _angular_core.WritableSignal<string>;
+    readonly isSupported: boolean;
+    readonly finalized: _angular_core.Signal<string>;
+    readonly finalized$: rxjs.Observable<string>;
+    constructor();
+    generateComponentId(): string;
+    isActiveComponent(componentId: string): boolean;
+    start(componentId: string): void;
+    stop(): void;
+    toggle(componentId: string): void;
+    clear(): void;
+    private setupRecognition;
+    private startRecognition;
+    private stopRecognition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpeechService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpeechService>;
+}
+
+export { SpeechService };

package/services/transformer/index.d.ts

@@ -0,0 +1,14 @@
+import { QuickJsService } from '@xxmachina/common/infra/external/quick-js';
+import * as i0 from '@angular/core';
+
+declare class TransformerService {
+    readonly quickJs: QuickJsService;
+    transform({ transformerTs, transformer, }: {
+        transformerTs?: string;
+        transformer?: (result: any) => any;
+    }, input: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TransformerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TransformerService>;
+}
+
+export { TransformerService };

package/stores/firestore/index.d.ts

@@ -0,0 +1,17 @@
+import * as rxjs from 'rxjs';
+import * as _xxmachina_common_domain_models from '@xxmachina/common/domain/models';
+
+declare function getFirestoreQueryStore(): {
+    list: () => rxjs.Observable<_xxmachina_common_domain_models.Query<any, any>[]>;
+    create: (item: any) => Promise<_xxmachina_common_domain_models.Query<any, any>>;
+    update: (item: any) => Promise<void>;
+    save: (item: any) => Promise<any>;
+};
+declare function getFirestoreResourceStore(): {
+    list: () => rxjs.Observable<_xxmachina_common_domain_models.Resource[]>;
+    create: (item: any) => Promise<_xxmachina_common_domain_models.Resource>;
+    update: (item: any) => Promise<void>;
+    save: (item: any) => Promise<any>;
+};
+
+export { getFirestoreQueryStore, getFirestoreResourceStore };

package/stores/hasura/index.d.ts

@@ -0,0 +1,17 @@
+import * as _xxmachina_common_domain_models from '@xxmachina/common/domain/models';
+import * as rxjs from 'rxjs';
+
+declare function getHasuraQueryStore(): {
+    list: () => rxjs.Observable<any[]>;
+    create: (item: any) => Promise<_xxmachina_common_domain_models.Query<any, any>>;
+    update: (item: any) => Promise<void>;
+    save: (item: any) => Promise<any>;
+};
+declare function getHasuraResourceStore(): {
+    list: () => rxjs.Observable<any[]>;
+    create: (item: any) => Promise<_xxmachina_common_domain_models.Resource>;
+    update: (item: any) => Promise<void>;
+    save: (item: any) => Promise<any>;
+};
+
+export { getHasuraQueryStore, getHasuraResourceStore };

package/stores/index.d.ts

@@ -0,0 +1,32 @@
+import * as _angular_core from '@angular/core';
+import * as _nx_ddd_common_domain from '@nx-ddd/common/domain';
+import * as _ng_atomic_common_stores_entities from '@ng-atomic/common/stores/entities';
+import { EntityStoreAdapter } from '@ng-atomic/common/stores/entities';
+import { Query, Resource } from '@xxmachina/common/domain/models';
+
+declare function provideQueryStore(useFactory: () => EntityStoreAdapter<Query>): {
+    provide: _angular_core.InjectionToken<{
+        entity: _nx_ddd_common_domain.Type<_ng_atomic_common_stores_entities.Entity>;
+        adapter: EntityStoreAdapter<_ng_atomic_common_stores_entities.Entity>;
+    }[]>;
+    multi: boolean;
+    useFactory: (injector: _angular_core.Injector) => {
+        entity: _nx_ddd_common_domain.Type<Query<any, any>>;
+        adapter: EntityStoreAdapter<Query<any, any>>;
+    };
+    deps: (typeof _angular_core.Injector)[];
+};
+declare function provideResourceStore(useFactory: () => EntityStoreAdapter<Resource>): {
+    provide: _angular_core.InjectionToken<{
+        entity: _nx_ddd_common_domain.Type<_ng_atomic_common_stores_entities.Entity>;
+        adapter: EntityStoreAdapter<_ng_atomic_common_stores_entities.Entity>;
+    }[]>;
+    multi: boolean;
+    useFactory: (injector: _angular_core.Injector) => {
+        entity: _nx_ddd_common_domain.Type<Resource>;
+        adapter: EntityStoreAdapter<Resource>;
+    };
+    deps: (typeof _angular_core.Injector)[];
+};
+
+export { provideQueryStore, provideResourceStore };

package/stores/inmemory/index.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { EntityStoreAdapter } from '@ng-atomic/common/stores/entities';
+import { Resource } from '@xxmachina/common/domain/models';
+
+interface InMemoryStoreOptions {
+    initialData?: Record<string, any>;
+}
+declare class InMemoryStore {
+    private readonly store$;
+    constructor(options?: InMemoryStoreOptions);
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T | undefined;
+    get$<T>(key: string): Observable<T | undefined>;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+    keys(): string[];
+    values(): any[];
+    entries(): [string, any][];
+    size(): number;
+    getAll(): Record<string, any>;
+    getAll$(): Observable<Record<string, any>>;
+    update<T>(key: string, updater: (value: T | undefined) => T): void;
+    merge(data: Record<string, any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InMemoryStore>;
+}
+
+declare function getInmemoryResourceStore(initialResources?: Resource[]): EntityStoreAdapter<Resource>;
+
+export { InMemoryStore, getInmemoryResourceStore };
+export type { InMemoryStoreOptions };

package/usecase/assistant/index.d.ts

@@ -0,0 +1,18 @@
+import { InfrastructureService } from '@xxmachina/common/infra';
+import { AssistantOperator } from '@xxmachina/common/domain/models';
+import * as i0 from '@angular/core';
+
+declare class AssistantService {
+    private infra;
+    constructor(infra: InfrastructureService);
+    list(): Promise<AssistantOperator[]>;
+    create(assistant: AssistantOperator): Promise<AssistantOperator>;
+    update(assistant: AssistantOperator): Promise<void>;
+    delete(assistantid: string): Promise<void>;
+    operate(assistantId: string, input: string): Promise<string>;
+    private scrape;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssistantService>;
+}
+
+export { AssistantService };

package/usecase/database/index.d.ts

@@ -0,0 +1,39 @@
+import * as _notionhq_client_build_src_api_endpoints from '@notionhq/client/build/src/api-endpoints';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+interface DatabaseConfig {
+    notionApiKey: string;
+    databaseIdToName: {
+        [key: string]: string;
+    };
+}
+declare function provideDatabaseConfig(useFactory: () => DatabaseConfig): {
+    provide: InjectionToken<DatabaseConfig>;
+    useFactory: () => DatabaseConfig;
+};
+declare class DatabaseService {
+    private config;
+    private notion;
+    get(databaseId: string): Promise<_notionhq_client_build_src_api_endpoints.GetDatabaseResponse>;
+    update(databaseId: string, body: any): Promise<_notionhq_client_build_src_api_endpoints.UpdateDatabaseResponse>;
+    listDatabases(): Promise<any[]>;
+    generateMermaidER(): Promise<string>;
+    getPageItems(dbId: string, name: string): Promise<any[]>;
+    getParent(parent: {
+        type: 'database_id';
+        database_id: string;
+    } | {
+        type: 'page_id';
+        page_id: string;
+    } | {
+        type: 'block_id';
+        block_id: string;
+    }): Promise<_notionhq_client_build_src_api_endpoints.PartialDatabaseObjectResponse | _notionhq_client_build_src_api_endpoints.PartialPageObjectResponse | _notionhq_client_build_src_api_endpoints.PartialBlockObjectResponse>;
+    getPath(obj: any): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseService>;
+}
+
+export { DatabaseService, provideDatabaseConfig };
+export type { DatabaseConfig };

package/usecase/graphql/index.d.ts

@@ -0,0 +1,17 @@
+import * as firebase_admin_data_connect from 'firebase-admin/data-connect';
+import * as _nx_ddd_any_func from '@nx-ddd/any-func';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+
+declare class GraphqlService {
+    protected http: HttpClient;
+    protected anyFunc: _nx_ddd_any_func.AnyFuncService;
+    protected dc: firebase_admin_data_connect.DataConnect;
+    constructor();
+    graphql(query: string): Promise<firebase_admin_data_connect.ExecuteGraphqlResponse<unknown>>;
+    makeQuery(instructions: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphqlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphqlService>;
+}
+
+export { GraphqlService };

package/usecase/index.d.ts

@@ -0,0 +1,73 @@
+import { InfrastructureService } from '@xxmachina/common/infra';
+import { AssistantOperator, Spec, Project, Google } from '@xxmachina/common/domain/models';
+import * as i0 from '@angular/core';
+import * as firebase_admin_data_connect from 'firebase-admin/data-connect';
+import * as _nx_ddd_any_func from '@nx-ddd/any-func';
+import { HttpClient } from '@angular/common/http';
+
+declare class AssistantService {
+    private infra;
+    constructor(infra: InfrastructureService);
+    list(): Promise<AssistantOperator[]>;
+    create(assistant: AssistantOperator): Promise<AssistantOperator>;
+    update(assistant: AssistantOperator): Promise<void>;
+    delete(assistantid: string): Promise<void>;
+    operate(assistantId: string, input: string): Promise<string>;
+    private scrape;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssistantService>;
+}
+
+declare class SpecService {
+    private infra;
+    constructor(infra: InfrastructureService);
+    list(): Promise<Spec[]>;
+    get(id: string): Promise<Spec>;
+    create(spec: Spec): Promise<Spec>;
+    update(spec: Partial<Spec>): Promise<void>;
+    delete(id: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpecService>;
+}
+
+declare class ProjectService {
+    private infra;
+    constructor(infra: InfrastructureService);
+    list(): Promise<Project[]>;
+    get(projectId: string): Promise<Project>;
+    create(project: Project): Promise<Project>;
+    update(project: Project): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProjectService>;
+}
+
+declare class LinkService {
+    infra: InfrastructureService;
+    constructor(infra: InfrastructureService);
+    saveGoogleLink(google: Google): Promise<[Google, boolean]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LinkService>;
+}
+
+declare class GraphqlService {
+    protected http: HttpClient;
+    protected anyFunc: _nx_ddd_any_func.AnyFuncService;
+    protected dc: firebase_admin_data_connect.DataConnect;
+    constructor();
+    graphql(query: string): Promise<firebase_admin_data_connect.ExecuteGraphqlResponse<unknown>>;
+    makeQuery(instructions: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphqlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphqlService>;
+}
+
+declare class UsecaseService {
+    readonly assistant: AssistantService;
+    readonly link: LinkService;
+    readonly project: ProjectService;
+    readonly spec: SpecService;
+    readonly graphql: GraphqlService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsecaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsecaseService>;
+}
+
+export { UsecaseService };

package/usecase/link/index.d.ts

@@ -0,0 +1,13 @@
+import { Google } from '@xxmachina/common/domain/models';
+import { InfrastructureService } from '@xxmachina/common/infra';
+import * as i0 from '@angular/core';
+
+declare class LinkService {
+    infra: InfrastructureService;
+    constructor(infra: InfrastructureService);
+    saveGoogleLink(google: Google): Promise<[Google, boolean]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LinkService>;
+}
+
+export { LinkService };

package/usecase/project/index.d.ts

@@ -0,0 +1,16 @@
+import { Project } from '@xxmachina/common/domain/models';
+import { InfrastructureService } from '@xxmachina/common/infra';
+import * as i0 from '@angular/core';
+
+declare class ProjectService {
+    private infra;
+    constructor(infra: InfrastructureService);
+    list(): Promise<Project[]>;
+    get(projectId: string): Promise<Project>;
+    create(project: Project): Promise<Project>;
+    update(project: Project): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProjectService>;
+}
+
+export { ProjectService };

package/usecase/spec/index.d.ts

@@ -0,0 +1,17 @@
+import { InfrastructureService } from '@xxmachina/common/infra';
+import { Spec } from '@xxmachina/common/domain/models';
+import * as i0 from '@angular/core';
+
+declare class SpecService {
+    private infra;
+    constructor(infra: InfrastructureService);
+    list(): Promise<Spec[]>;
+    get(id: string): Promise<Spec>;
+    create(spec: Spec): Promise<Spec>;
+    update(spec: Partial<Spec>): Promise<void>;
+    delete(id: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpecService>;
+}
+
+export { SpecService };

package/utils/crypto/index.d.ts

@@ -0,0 +1,9 @@
+declare function float32Buffer(arr: number[]): Buffer<ArrayBuffer>;
+declare function _bufferFloat32(buffer: Buffer): Float32Array;
+declare function bufferFloat32(buffer: Buffer): number[];
+declare function float64Buffer(arr: number[]): Buffer<ArrayBuffer>;
+declare function _bufferFloat64(buffer: Buffer): Float64Array;
+declare function bufferFloat64(buffer: Buffer): number[];
+declare function hash(input: string): string;
+
+export { _bufferFloat32, _bufferFloat64, bufferFloat32, bufferFloat64, float32Buffer, float64Buffer, hash };

package/utils/index.d.ts

@@ -0,0 +1,5 @@
+import { JsonSchema } from 'json-schema-library';
+
+declare function extractDisplayFields(schema: JsonSchema, prefix?: string, childrenKey?: string): string[];
+
+export { extractDisplayFields };